Invio di notifiche push ad Android con Hub di notifica di AzureSending push notifications to Android with Azure Notification Hubs

OverviewOverview

Importante

Questo argomento illustra le notifiche push con Google Cloud Messaging (GCM).This topic demonstrates push notifications with Google Cloud Messaging (GCM). Se si sta ancora usando Google Firebase Messaging (FCM), vedere Invio di notifiche push ad Android con Hub di notifica di Azure e Firebase Cloud Messaging.If you are using Google's Firebase Cloud Messaging (FCM), see Sending push notifications to Android with Azure Notification Hubs and FCM.

Questa esercitazione illustra come usare Hub di notifica di Azure per inviare notifiche push a un'applicazione per Android.This tutorial shows you how to use Azure Notification Hubs to send push notifications to an Android application. In questa esercitazione verrà creata un'app Android vuota che riceve notifiche push usando il servizio Google Cloud Messaging (GCM).You'll create a blank Android app that receives push notifications by using Google Cloud Messaging (GCM).

Obiettivo di questo articolo è consentire di iniziare a usare Hub di notifica di Azure il prima possibile.The goal of this article is to help you get started using Azure Notification Hubs as quickly as possible. L'articolo presenta uno scenario di trasmissione molto semplice che illustra i concetti di base di Hub di notifica.The article presents a very simple broadcast scenario that focuses on the basic concepts of Notification Hubs.

Se si ha già familiarità con Hub di notifica, è possibile selezionare un altro argomento nel riquadro di spostamento a sinistra o passare agli articoli pertinenti nella sezione "Passaggi successivi".If you are already familiar with Notification Hubs, you might want to select another topic from the left navigation or go to the relevant articles in the "Next steps" section.

I commenti e suggerimenti inviati verranno presi seriamente in considerazione.We take your feedback seriously. Se si riscontrano difficoltà nel completare questo argomento o si hanno suggerimenti per migliorarne il contenuto, è possibile lasciare un commento alla fine dell'articolo.If you have any difficulty completing this topic, or if you have recommendations for improving this content, we invite you to provide feedback at the end of the article.

Il codice completo per questa esercitazione può essere scaricato da GitHub qui.The completed code for this tutorial can be downloaded from GitHub here.

PrerequisitiPrerequisites

Importante

Per completare l'esercitazione, è necessario disporre di un account Azure attivo.To complete this tutorial, you must have an active Azure account. Se non si dispone di un account, è possibile creare un account di valutazione gratuita in pochi minuti.If you don't have an account, you can create a free trial account in just a couple of minutes. Per informazioni dettagliate, vedere la pagina relativa alla versione di valutazione gratuita di Azure.For details, see Azure Free Trial.

Oltre a un account Azure attivo come indicato sopra, questa esercitazione richiede solo la versione più recente di Android Studio.In addition to an active Azure account mentioned above, this tutorial only requires the latest version of Android Studio.

Il completamento di questa esercitazione costituisce un prerequisito per tutte le altre esercitazioni di Hub di notifica relative ad app Android.Completing this tutorial is a prerequisite for all other Notification Hubs tutorials for Android apps.

Creazione di un progetto che supporta Google Cloud MessagingCreating a project that supports Google Cloud Messaging

  1. Passare a Google Cloud Consoleed eseguire l'accesso con le credenziali dell'account Google.Navigate to the Google Cloud Console, sign in with your Google account credentials.
  2. Fare clic su Crea progetto, digitare un nome di progetto e quindi fare clic su Crea.Click Create Project, type a project name, then click Create. Se necessario, eseguire la verifica SMS, quindi fare nuovamente clic su Crea .If requested, carry out the SMS Verification, and click Create again.

    Creare un nuovo progetto

    Digitare il nuovo nome del progetto e fare clic su Crea progetto.Type in your new Project name and click Create project.

  3. Fare clic sul pulsante Utilities and More (Utilità e altro) e quindi su Informazioni progetto.Click the Utilities and More button and then click Project Information. Prendere nota del valore di Project Number.Make a note of the Project Number. Sarà necessario impostare questo valore come variabile SenderId nell'app client.You will need to set this value as the SenderId variable in the client app.

    Utilità e altro ancora

  4. Nel dashboard del progetto fare clic su Google Cloud Messaging in Mobile APIs (API per dispositivi mobili), quindi nella pagina successiva fare clic su Enable API (Abilita API) e accettare le condizioni del servizio.In the project dashboard, under Mobile APIs, click Google Cloud Messaging, then on the next page click Enable API and accept the terms of service.

    Abilitare GCM

    Abilitare GCM

  5. Nel dashboard del progetto fare clic su Credenziali > Crea credenziale > Chiave API.In the project dashboard, Click Credentials > Create Credential > API Key.

  6. In Crea una nuova chiave fare clic su Chiave server, digitare un nome per la chiave e quindi fare clic su Crea.In Create a new key, click Server key, type a name for your key, then click Create.
  7. Prendere nota del valore di API KEY .Make a note of the API KEY value.

    Questo valore della chiave dell'API verrà usato successivamente per abilitare Azure per l'autenticazione con GCM e l'invio di notifiche push per conto dell'app.You will use this API key value to enable Azure to authenticate with GCM and send push notifications on behalf of your app.

Configurare un nuovo hub di notificaConfigure a new notification hub

  1. Accedere al portale di Azure.Sign in to the Azure portal.

  2. Selezionare Nuovo > Web e dispositivi mobili > Hub di notifica.Select New > Web + Mobile > Notification Hub.

    Portale di Azure: creare un hub di notifica

  3. Nella casella Hub di notifica digitare un nome univoco.In the Notification Hub box, type a unique name. Selezionare l'area, la sottoscrizione e il gruppo di risorse (se già disponibili).Select your Region, Subscription, and Resource Group (if you have one already).

    Se si ha già un spazio dei nomi del bus di servizio in cui si vuole creare l'hub, seguire questa procedura:If you already have a service bus namespace that you want to create the hub in, do the following:

    a.a. Nell'area Spazio dei nomi selezionare il collegamento Seleziona esistente.In the Namespace area, select the Select Existing link.

    b.b. Selezionare Crea.Select Create.

    Se non si ha già uno spazio dei nomi del bus di servizio, è possibile usare il nome predefinito, che viene creato in base al nome dell'hub (se lo spazio dei nomi è disponibile).If you don't already have a service bus namespace, you can use the default name, which is created based on the hub name (if the namespace name is available).

    Portale di Azure: impostare le proprietà dell'hub di notifica

    Dopo avere creato lo spazio dei nomi e l'hub di notifica, viene aperto il portale di Azure.After you've created the namespace and notification hub, the Azure portal opens.

    Portale di Azure: pagina del portale dell'hub di notifica

  4. Selezionare Impostazioni > Criteri di accesso.Select Settings > Access Policies. Prendere nota delle due stringhe di connessione disponibili.Note the two connection strings that are available to you. Saranno necessarie in un secondo momento per gestire le notifiche push.You will need them to handle push notifications later.

    Portale di Azure: stringhe di connessione dell'hub di notifica

  6.  6. Nel pannello Impostazioni selezionare Servizi di notifica, quindi Google (GCM).In the Settings blade, select Notification Services and then Google (GCM). Immettere la chiave API e fare clic su Salva.Enter the API key and click Save.

  Hub di notifica di Azure - Google (GCM)

A questo punto, l'hub di notifica è configurato per l'uso con GCM e sono disponibili le stringhe di connessione per registrare l'app per l'invio e la ricezione di notifiche push.Your notification hub is now configured to work with GCM, and you have the connection strings to both register your app to receive and send push notifications.

Connettere l'app all'hub di notificaConnect your app to the notification hub

Creare un nuovo progetto AndroidCreate a new Android project

  1. In Android Studio avviare un nuovo progetto Android Studio.In Android Studio, start a new Android Studio project.

    Android Studio: nuovo progetto

  2. Scegliere il fattore di forma Phone and Tablet (Telefono e tablet) e la versione Minimum SDK (SDK minimo) che si vuole supportare.Choose the Phone and Tablet form factor and the Minimum SDK that you want to support. Quindi fare clic su Next.Then click Next.

    Android Studio: flusso di lavoro di creazione del progetto

  3. Scegliere Empty Activity (Attività vuota) per l'attività principale, fare clic su Avanti, quindi su Fine.Choose Empty Activity for the main activity, click Next, and then click Finish.

Aggiungere Google Play Services al progettoAdd Google Play services to the project

  1. Aprire Android SDK Manager facendo clic sull'icona della barra degli strumenti di Android Studio o su Strumenti -> Android -> SDK Manager nel menu.Open the Android SDK Manager by clicking the icon on the toolbar of Android Studio or by clicking Tools -> Android -> SDK Manager on the menu. Trovare la versione di destinazione di Android SDK usata nel progetto, aprirla facendo clic su Show Package Details (Visualizza dettagli pacchetto) e quindi scegliere Google APIs (API Google), se non è già installato.Locate the target version of the Android SDK that is used in your project , open it by clicking Show Package Details, and choose Google APIs, if it is not already installed.
  2. Fare sulla scheda SDK Tools . Se Google Play Service non è già installato, fare clic su Google Play Services come mostrato di seguito.Click the SDK Tools tab. If you haven't already installed Google Play Service, click Google Play Services as shown below. Fare quindi clic su Apply per installarlo.Then click Apply to install.

    Prendere nota del percorso dell'SDK per l'uso in un passaggio successivo.Note the SDK path, for use in a later step.

  3. Aprire il file build.gradle nella directory dell'app.Open the build.gradle file in the app directory.

  4. In dependenciesaggiungere questa riga:Add this line under dependencies:

        compile 'com.google.android.gms:play-services-gcm:9.2.0'
    
  5. Fare clic sul pulsante Sync Project with Gradle Files sulla barra degli strumenti.Click the Sync Project with Gradle Files icon in the tool bar.
  6. Aprire AndroidManifest.xml e aggiungere il tag seguente al tag application .Open AndroidManifest.xml and add this tag to the application tag.

     <meta-data android:name="com.google.android.gms.version"
         android:value="@integer/google_play_services_version" />
    

Aggiunta di librerie dell'Hub di notifica di AzureAdding Azure Notification Hubs libraries

  1. Nel file Build.Gradle relativo all'app aggiungere le righe seguenti alla sezione delle dipendenze.In the Build.Gradle file for the app, add the following lines in the dependencies section.

     compile 'com.microsoft.azure:notification-hubs-android-sdk:0.4@aar'
     compile 'com.microsoft.azure:azure-notifications-handler:1.0.1@aar'
    
  2. Aggiungere l'archivio seguente dopo la sezione dependencies .Add the following repository after the dependencies section.

     repositories {
         maven {
             url "http://dl.bintray.com/microsoftazuremobile/SDK"
         }
     }
    

Aggiornamento del file AndroidManifest.xmlUpdating the AndroidManifest.xml.

  1. Per supportare GCM è necessario implementare un servizio listener Instance ID nel codice, che consente di ottenere token di registrazione usando l'API Instance ID di Google.To support GCM, we must implement a Instance ID listener service in our code which is used to obtain registration tokens using Google's Instance ID API. In questa esercitazione verrà assegnato il nome MyInstanceIDServicealla classe.In this tutorial we will name the class MyInstanceIDService.

    Aggiungere la definizione del servizio seguente al file AndroidManifest.xml, all'interno del tag <application> .Add the following service definition to the AndroidManifest.xml file, inside the <application> tag. Sostituire il segnaposto <your package> con il nome effettivo del pacchetto visualizzato all'inizio del file AndroidManifest.xml.Replace the <your package> placeholder with the your actual package name shown at the top of the AndroidManifest.xml file.

     <service android:name="<your package>.MyInstanceIDService" android:exported="false">
         <intent-filter>
             <action android:name="com.google.android.gms.iid.InstanceID"/>
         </intent-filter>
     </service>
    
  2. Dopo la ricezione del token di registrazione di GCM dall'API Instance ID, lo si userà per la registrazione con Hub di notifica di Azure.Once we have received our GCM registration token from the Instance ID API, we will use it to register with the Azure Notification Hub. La registrazione verrà supportata in background mediante un IntentService denominato RegistrationIntentService.We will support this registration in the background using an IntentService named RegistrationIntentService. Il servizio sarà anche responsabile dell' aggiornamento del token di registrazione di GCM.This service will also be responsible for refreshing our GCM registration token.

    Aggiungere la definizione del servizio seguente al file AndroidManifest.xml, all'interno del tag <application> .Add the following service definition to the AndroidManifest.xml file, inside the <application> tag. Sostituire il segnaposto <your package> con il nome effettivo del pacchetto visualizzato all'inizio del file AndroidManifest.xml.Replace the <your package> placeholder with the your actual package name shown at the top of the AndroidManifest.xml file.

     <service
         android:name="<your package>.RegistrationIntentService"
         android:exported="false">
     </service>
    
  3. Verrà definito anche un ricevitore per la ricezione di notifiche.We will also define a receiver to receive notifications. Aggiungere la definizione del ricevitore seguente al file AndroidManifest.xml, nel tag <application> .Add the following receiver definition to the AndroidManifest.xml file, inside the <application> tag. Sostituire il segnaposto <your package> con il nome effettivo del pacchetto visualizzato all'inizio del file AndroidManifest.xml.Replace the <your package> placeholder with the your actual package name shown at the top of the AndroidManifest.xml file.

     <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="<your package name>" />
         </intent-filter>
     </receiver>
    
  4. Aggiungere le necessarie autorizzazioni correlate a GCM riportate di seguito sotto il tag </application>.Add the following necessary GCM related permissions below the </application> tag. Sostituire <your package> con il nome del pacchetto visualizzato all'inizio del file AndroidManifest.xml.Make sure to replace <your package> with the package name shown at the top of the AndroidManifest.xml file.

    Per altre informazioni su queste autorizzazioni, vedere Setup a GCM Client app for Android(Configurare un'app client di GCM per Android).For more information on these permissions, see Setup a GCM Client app for Android.

     <uses-permission android:name="android.permission.INTERNET"/>
     <uses-permission android:name="android.permission.GET_ACCOUNTS"/>
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
     <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
    
     <permission android:name="<your package>.permission.C2D_MESSAGE" android:protectionLevel="signature" />
     <uses-permission android:name="<your package>.permission.C2D_MESSAGE"/>
    

Aggiunta di codiceAdding code

  1. Nella visualizzazione del progetto espandere app > src > main > java.In the Project View, expand app > src > main > java. Fare clic con il pulsante destro del mouse sulla cartella del pacchetto in java, scegliere Nuovo, quindi selezionare Java Class (Classe Java).Right-click your package folder under java, click New, and then click Java Class. Aggiungere una nuova classe denominata NotificationSettings.Add a new class named NotificationSettings.

    Android Studio: nuova classe Java

    Aggiornare questi tre segnaposto nel codice seguente per la classe NotificationSettings :Make sure to update the these three placeholders in the following code for the NotificationSettings class:

    • SenderId: numero di progetto ottenuto in precedenza in Google Cloud Console(Console Cloud di Google).SenderId: The project number you obtained earlier in the Google Cloud Console.
    • HubListenConnectionString: stringa di connessione DefaultListenAccessSignature per l'hub.HubListenConnectionString: The DefaultListenAccessSignature connection string for your hub. È possibile copiare la stringa di connessione facendo clic su Criteri di accesso nel pannello Impostazioni dell'hub nel portale di Azure.You can copy that connection string by clicking Access Policies on the Settings blade of your hub on the [Azure Portal].
    • HubName: usare il nome dell'Hub di notifica visualizzato nel pannello dell'hub nel portale di Azure.HubName: Use the name of your notification hub that appears in the hub blade in the [Azure Portal].

      NotificationSettings :NotificationSettings code:

      classe pubblica NotificationSettings {public class NotificationSettings {

        public static String SenderId = "<Your project number>";
        public static String HubName = "<Your HubName>";
        public static String HubListenConnectionString = "<Your default listen connection string>";
      

      }}

  2. Usando la procedura precedente, aggiungere un'altra nuova classe denominata MyInstanceIDService.Using the steps above, add another new class named MyInstanceIDService. Questa sarà l'implementazione del servizio listener Instance ID.This will be our Instance ID listener service implementation.

    Il codice per questa classe chiamerà IntentService per aggiornare il token di GCM in background.The code for this class will call our IntentService to refresh the GCM token in the background.

     import android.content.Intent;
     import android.util.Log;
     import com.google.android.gms.iid.InstanceIDListenerService;
    
     public class MyInstanceIDService extends InstanceIDListenerService {
    
         private static final String TAG = "MyInstanceIDService";
    
         @Override
         public void onTokenRefresh() {
    
             Log.i(TAG, "Refreshing GCM Registration Token");
    
             Intent intent = new Intent(this, RegistrationIntentService.class);
             startService(intent);
         }
     };
    
  3. Aggiungere al progetto un'altra nuova classe denominata RegistrationIntentService.Add another new class to your project named, RegistrationIntentService. Questa sarà l'implementazione di IntentService che gestirà l'aggiornamento del token di GCM e la registrazione nell'hub di notifica.This will be the implementation for our IntentService that will handle refreshing the GCM token and registering with the notification hub.

    Usare il codice seguente per la classe.Use the following code for this class.

     import android.app.IntentService;
     import android.content.Intent;
     import android.content.SharedPreferences;
     import android.preference.PreferenceManager;
     import android.util.Log;
    
     import com.google.android.gms.gcm.GoogleCloudMessaging;
     import com.google.android.gms.iid.InstanceID;
     import com.microsoft.windowsazure.messaging.NotificationHub;
    
     public class RegistrationIntentService extends IntentService {
    
         private static final String TAG = "RegIntentService";
    
         private NotificationHub hub;
    
         public RegistrationIntentService() {
             super(TAG);
         }
    
         @Override
         protected void onHandleIntent(Intent intent) {        
             SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
             String resultString = null;
             String regID = null;
    
             try {
                 InstanceID instanceID = InstanceID.getInstance(this);
                 String token = instanceID.getToken(NotificationSettings.SenderId,
                         GoogleCloudMessaging.INSTANCE_ID_SCOPE);        
                 Log.i(TAG, "Got GCM Registration Token: " + token);
    
                 // Storing the registration id that indicates whether the generated token has been
                 // sent to your server. If it is not stored, send the token to your server,
                 // otherwise your server should have already received the token.
                 if ((regID=sharedPreferences.getString("registrationID", null)) == null) {        
                     NotificationHub hub = new NotificationHub(NotificationSettings.HubName,
                             NotificationSettings.HubListenConnectionString, this);
                     Log.i(TAG, "Attempting to register with NH using token : " + token);
    
                     regID = hub.register(token).getRegistrationId();
    
                     // If you want to use tags...
                     // Refer to : https://azure.microsoft.com/en-us/documentation/articles/notification-hubs-routing-tag-expressions/
                     // regID = hub.register(token, "tag1", "tag2").getRegistrationId();
    
                     resultString = "Registered Successfully - RegId : " + regID;
                     Log.i(TAG, resultString);        
                     sharedPreferences.edit().putString("registrationID", regID ).apply();
                 } else {
                     resultString = "Previously Registered Successfully - RegId : " + regID;
                 }
             } catch (Exception e) {
                 Log.e(TAG, resultString="Failed to complete token refresh", e);
                 // If an exception happens while fetching the new token or updating our registration data
                 // on a third-party server, this ensures that we'll attempt the update at a later time.
             }
    
             // Notify UI that registration has completed.
             if (MainActivity.isVisible) {
                 MainActivity.mainActivity.ToastNotify(resultString);
             }
         }
     }
    
  4. Nella classe MainActivity aggiungere le istruzioni import seguenti sopra la dichiarazione della classe.In your MainActivity class, add the following import statements above the class declaration.

     import com.google.android.gms.common.ConnectionResult;
     import com.google.android.gms.common.GoogleApiAvailability;
     import com.google.android.gms.gcm.*;
     import com.microsoft.windowsazure.notifications.NotificationsManager;
     import android.util.Log;
     import android.widget.TextView;
     import android.widget.Toast;
    
  5. Aggiungere i seguenti membri privati nella parte superiore della classe.Add the following private members at the top of the class. Verranno usati per verificare la disponibilità di Google Play Services come consigliato da Google.We will use these check the availability of Google Play Services as recommended by Google.

     public static MainActivity mainActivity;
     public static Boolean isVisible = false;    
     private GoogleCloudMessaging gcm;
     private static final int PLAY_SERVICES_RESOLUTION_REQUEST = 9000;
    
  6. Nella classe MainActivity aggiungere il metodo seguente alla disponibilità di Google Play Services.In your MainActivity class, add the following method to the availability of Google Play Services.

     /**
      * Check the device to make sure it has the Google Play Services APK. If
      * it doesn't, display a dialog that allows users to download the APK from
      * the Google Play Store or enable it in the device's system settings.
      */
     private boolean checkPlayServices() {
         GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();
         int resultCode = apiAvailability.isGooglePlayServicesAvailable(this);
         if (resultCode != ConnectionResult.SUCCESS) {
             if (apiAvailability.isUserResolvableError(resultCode)) {
                 apiAvailability.getErrorDialog(this, resultCode, PLAY_SERVICES_RESOLUTION_REQUEST)
                         .show();
             } else {
                 Log.i(TAG, "This device is not supported by Google Play Services.");
                 ToastNotify("This device is not supported by Google Play Services.");
                 finish();
             }
             return false;
         }
         return true;
     }
    
  7. Nella classe MainActivity aggiungere il codice seguente che cercherà Google Play Services prima di chiamare IntentService per ottenere il token di registrazione di GCM e registrarlo nell'hub di notifica.In your MainActivity class, add the following code that will check for Google Play Services before calling your IntentService to get your GCM registration token and register with your notification hub.

     public void registerWithNotificationHubs()
     {
         Log.i(TAG, " Registering with Notification Hubs");
    
         if (checkPlayServices()) {
             // Start IntentService to register this application with GCM.
             Intent intent = new Intent(this, RegistrationIntentService.class);
             startService(intent);
         }
     }
    
  8. Nel metodo OnCreate della classe MainActivity aggiungere il codice seguente per avviare il processo di registrazione quando viene creata l'attività.In the OnCreate method of the MainActivity class, add the following code to start the registration process when activity is created.

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
    
         mainActivity = this;
         NotificationsManager.handleNotifications(this, NotificationSettings.SenderId, MyHandler.class);
         registerWithNotificationHubs();
     }
    
  9. Aggiungere questi altri metodi a MainActivity per verificare lo stato dell'app e segnalare lo stato nell'app.Add these additional methods to the MainActivity to verify app state and report status in your app.

     @Override
     protected void onStart() {
         super.onStart();
         isVisible = true;
     }
    
     @Override
     protected void onPause() {
         super.onPause();
         isVisible = false;
     }
    
     @Override
     protected void onResume() {
         super.onResume();
         isVisible = true;
     }
    
     @Override
     protected void onStop() {
         super.onStop();
         isVisible = false;
     }
    
     public void ToastNotify(final String notificationMessage) {
         runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 Toast.makeText(MainActivity.this, notificationMessage, Toast.LENGTH_LONG).show();
                 TextView helloText = (TextView) findViewById(R.id.text_hello);
                 helloText.setText(notificationMessage);
             }
         });
     }
    
  10. Il metodo ToastNotify usa il controllo "Hello World" TextView per segnalare lo stato e le notifiche in modo permanente nell'app.The ToastNotify method uses the "Hello World" TextView control to report status and notifications persistently in the app. Nel layout di activity_main.xml aggiungere l'ID seguente per il controllo.In your activity_main.xml layout, add the following id for that control.

    android:id="@+id/text_hello"
    
  11. Verrà quindi aggiunta una sottoclasse per il ricevitore definita nel file AndroidManifest.xml.Next we will add a subclass for our receiver we defined in the AndroidManifest.xml. Aggiungere al progetto un'altra nuova classe denominata MyHandler.Add another new class to your project named MyHandler.
  12. Aggiungere le istruzioni import seguenti all'inizio di MyHandler.java:Add the following import statements at the top of MyHandler.java:

    import android.app.NotificationManager;
    import android.app.PendingIntent;
    import android.content.Context;
    import android.content.Intent;
    import android.os.Bundle;
    import android.support.v4.app.NotificationCompat;
    import com.microsoft.windowsazure.notifications.NotificationsHandler;
    
  13. Aggiungere il codice seguente per la classe MyHandler impostandola come sottoclasse di com.microsoft.windowsazure.notifications.NotificationsHandler.Add the following code for the MyHandler class making it a subclass of com.microsoft.windowsazure.notifications.NotificationsHandler.

    Questo codice ignora il metodo OnReceive , in modo che il gestore segnali le notifiche ricevute.This code overrides the OnReceive method, so the handler will report notifications that are received. Il gestore invia anche la notifica push al gestore delle notifiche di Android usando il metodo sendNotification() .The handler also sends the push notification to the Android notification manager by using the sendNotification() method. Il metodo sendNotification() deve essere eseguito quando l'app non è in esecuzione e si riceve una notifica.The sendNotification() method should be executed when the app is not running and a notification is received.

    public class MyHandler extends NotificationsHandler {
        public static final int NOTIFICATION_ID = 1;
        private NotificationManager mNotificationManager;
        NotificationCompat.Builder builder;
        Context ctx;
    
        @Override
        public void onReceive(Context context, Bundle bundle) {
            ctx = context;
            String nhMessage = bundle.getString("message");
            sendNotification(nhMessage);
            if (MainActivity.isVisible) {
                MainActivity.mainActivity.ToastNotify(nhMessage);
            }
        }
    
        private void sendNotification(String msg) {
    
            Intent intent = new Intent(ctx, MainActivity.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    
            mNotificationManager = (NotificationManager)
                    ctx.getSystemService(Context.NOTIFICATION_SERVICE);
    
            PendingIntent contentIntent = PendingIntent.getActivity(ctx, 0,
                    intent, PendingIntent.FLAG_ONE_SHOT);
    
            Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
            NotificationCompat.Builder mBuilder =
                    new NotificationCompat.Builder(ctx)
                            .setSmallIcon(R.mipmap.ic_launcher)
                            .setContentTitle("Notification Hub Demo")
                            .setStyle(new NotificationCompat.BigTextStyle()
                                    .bigText(msg))
                            .setSound(defaultSoundUri)
                            .setContentText(msg);
    
            mBuilder.setContentIntent(contentIntent);
            mNotificationManager.notify(NOTIFICATION_ID, mBuilder.build());
        }
    }
    
  14. Sulla barra dei menu in Android Studio fare clic su Compila > Ricompila il progetto per assicurarsi che non ci siano errori nel codice.In Android Studio on the menu bar, click Build > Rebuild Project to make sure that no errors are present in your code.

Invio di notifiche pushSending push notifications

È possibile testare la ricezione delle notifiche push nell'app inviandole tramite il portale di Azure; cercare la sezione Risoluzione dei problemi nel pannello dell'hub, come illustrato di seguito.You can test receiving push notifications in your app by sending them via the [Azure Portal] - look for the Troubleshooting Section in the hub blade, as shown below.

Hub di notifica di Azure: test dell'invio

Le notifiche push vengono in genere inviate in un servizio back-end come App per dispositivi mobili o ASP.NET usando una libreria compatibile.Push notifications are normally sent in a back-end service like Mobile Apps or ASP.NET using a compatible library. È anche possibile utilizzare l'API REST direttamente per inviare messaggi di notifica se una libreria non è disponibile per il back-end.You can also use the REST API directly to send notification messages if a library is not available for your back-end.

Di seguito è riportato un elenco di altre esercitazioni, che è possibile esaminare per l'invio di notifiche:Here is a list of some other tutorials you may want to review for sending notifications:

Nella sezione successiva dell'esercitazione si apprenderà come usare l' interfaccia REST di Hub di notifica per inviare il messaggio di notifica direttamente nell'applicazione.In the next section of the tutorial, you will learn how to use the Notification Hub REST interface to send the notification message directly in your app. Tutti i dispositivi registrati ricevono la notifica inviata da qualsiasi dispositivo.All registered devices receive the notification sent by any device.

(Facoltativo) Inviare notifiche push direttamente dall'app(Optional) Send push notifications directly from the app

In genere, le notifiche vengono inviate tramite un server back-end.Normally, you would send notifications using a backend server. In alcuni casi può essere necessario inviare notifiche push direttamente dall'applicazione client.For some cases, you might want to be able to send push notifications directly from the client application. Questa sezione illustra come inviare notifiche dal client usando l' API REST dell'Hub di notifica di Azure.This section explains how to send notifications from the client using the Azure Notification Hub REST API.

  1. Nella visualizzazione del progetto in Android Studio espandere App > src > main > res > layout.In Android Studio Project View, expand App > src > main > res > layout. Aprire il file di layout activity_main.xml e fare clic sulla scheda Text (Testo) per aggiornare il contenuto di testo del file.Open the activity_main.xml layout file and click the Text tab to update the text contents of the file. Aggiornarlo con il codice seguente che aggiunge i nuovi controlli Button e EditText per l'invio di messaggi di notifica push all'hub di notifica.Update it with the code below, which adds new Button and EditText controls for sending push notification messages to the notification hub. Aggiungere questo codice alla fine, subito prima di </RelativeLayout>.Add this code at the bottom, just before </RelativeLayout>.

     <Button
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:text="@string/send_button"
     android:id="@+id/sendbutton"
     android:layout_centerVertical="true"
     android:layout_centerHorizontal="true"
     android:onClick="sendNotificationButtonOnClick" />
    
     <EditText
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:id="@+id/editTextNotificationMessage"
     android:layout_above="@+id/sendbutton"
     android:layout_centerHorizontal="true"
     android:layout_marginBottom="42dp"
     android:hint="@string/notification_message_hint" />
    
  2. Nella visualizzazione del progetto in Android Studio espandere App > src > main > res > values.In Android Studio Project View, expand App > src > main > res > values. Aprire il file strings.xml e aggiungere i valori di stringa a cui fanno riferimento i nuovi controlli Button e EditText.Open the strings.xml file and add the string values that are referenced by the new Button and EditText controls. Aggiungerli alla fine del file, subito prima di </resources>.Add these at the bottom of the file, just before </resources>.

     <string name="send_button">Send Notification</string>
     <string name="notification_message_hint">Enter notification message text</string>
    
  3. Nel file NotificationSetting.java aggiungere l'impostazione seguente alla classe NotificationSettings.In your NotificationSetting.java file, add the following setting to the NotificationSettings class.

    Aggiornare HubFullAccess con la stringa di connessione DefaultFullSharedAccessSignature per l'hub.Update HubFullAccess with the DefaultFullSharedAccessSignature connection string for your hub. Questa stringa di connessione può essere copiata dal portale di Azure facendo clic su Criteri di accesso nel pannello Impostazioni dell'hub di notifica.This connection string can be copied from the [Azure Portal] by clicking Access Policies on the Settings blade for your notification hub.

     public static String HubFullAccess = "<Enter Your DefaultFullSharedAccess Connection string>";
    
  4. Nel file MainActivity.java aggiungere le istruzioni import seguenti sopra la classe MainActivity.In your MainActivity.java file, add the following import statements above the MainActivity class.

     import java.io.BufferedOutputStream;
     import java.io.BufferedReader;
     import java.io.InputStreamReader;
     import java.io.OutputStream;
     import java.net.HttpURLConnection;
     import java.net.URL;
     import java.net.URLEncoder;
     import javax.crypto.Mac;
     import javax.crypto.spec.SecretKeySpec;
     import android.util.Base64;
     import android.view.View;
     import android.widget.EditText;
    
  5. Nel file MainActivity.java aggiungere i membri seguenti all'inizio della classe MainActivity.In your MainActivity.java file, add the following members at the top of the MainActivity class.

     private String HubEndpoint = null;
     private String HubSasKeyName = null;
     private String HubSasKeyValue = null;
    
  6. È necessario creare un token SaS (Software Access Signature) per autenticare una richiesta POST per l'invio di messaggi all'hub di notifica.You must create a Software Access Signature (SaS) token to authenticate a POST request to send messages to your notification hub. Per eseguire questa operazione, analizzare i dati della chiave dalla stringa di connessione e quindi creare il token di firma di accesso condiviso come indicato in Concetti comuni nelle informazioni di riferimento sull'API REST.This is done by parsing the key data from the connection string and then creating the SaS token, as mentioned in the Common Concepts REST API reference. Il codice seguente è un esempio di implementazione.The following code is an example implementation.

    In MainActivity.java aggiungere il metodo seguente alla classe MainActivity per analizzare la stringa di connessione.In MainActivity.java, add the following method to the MainActivity class to parse your connection string.

     /**
      * Example code from http://msdn.microsoft.com/library/azure/dn495627.aspx
      * to parse the connection string so a SaS authentication token can be
      * constructed.
      *
      * @param connectionString This must be the DefaultFullSharedAccess connection
      *                         string for this example.
      */
     private void ParseConnectionString(String connectionString)
     {
         String[] parts = connectionString.split(";");
         if (parts.length != 3)
             throw new RuntimeException("Error parsing connection string: "
                     + connectionString);
    
         for (int i = 0; i < parts.length; i++) {
             if (parts[i].startsWith("Endpoint")) {
                 this.HubEndpoint = "https" + parts[i].substring(11);
             } else if (parts[i].startsWith("SharedAccessKeyName")) {
                 this.HubSasKeyName = parts[i].substring(20);
             } else if (parts[i].startsWith("SharedAccessKey")) {
                 this.HubSasKeyValue = parts[i].substring(16);
             }
         }
     }
    
  7. In MainActivity.java aggiungere il metodo seguente alla classe MainActivity per creare un token di autenticazione di firma di accesso condiviso.In MainActivity.java, add the following method to the MainActivity class to create a SaS authentication token.

     /**
      * Example code from http://msdn.microsoft.com/library/azure/dn495627.aspx to
      * construct a SaS token from the access key to authenticate a request.
      *
      * @param uri The unencoded resource URI string for this operation. The resource
      *            URI is the full URI of the Service Bus resource to which access is
      *            claimed. For example,
      *            "http://<namespace>.servicebus.windows.net/<hubName>"
      */
     private String generateSasToken(String uri) {
    
         String targetUri;
         String token = null;
         try {
             targetUri = URLEncoder
                     .encode(uri.toString().toLowerCase(), "UTF-8")
                     .toLowerCase();
    
             long expiresOnDate = System.currentTimeMillis();
             int expiresInMins = 60; // 1 hour
             expiresOnDate += expiresInMins * 60 * 1000;
             long expires = expiresOnDate / 1000;
             String toSign = targetUri + "\n" + expires;
    
             // Get an hmac_sha1 key from the raw key bytes
             byte[] keyBytes = HubSasKeyValue.getBytes("UTF-8");
             SecretKeySpec signingKey = new SecretKeySpec(keyBytes, "HmacSHA256");
    
             // Get an hmac_sha1 Mac instance and initialize with the signing key
             Mac mac = Mac.getInstance("HmacSHA256");
             mac.init(signingKey);
    
             // Compute the hmac on input data bytes
             byte[] rawHmac = mac.doFinal(toSign.getBytes("UTF-8"));
    
             // Using android.util.Base64 for Android Studio instead of
             // Apache commons codec
             String signature = URLEncoder.encode(
                     Base64.encodeToString(rawHmac, Base64.NO_WRAP).toString(), "UTF-8");
    
             // Construct authorization string
             token = "SharedAccessSignature sr=" + targetUri + "&sig="
                     + signature + "&se=" + expires + "&skn=" + HubSasKeyName;
         } catch (Exception e) {
             if (isVisible) {
                 ToastNotify("Exception Generating SaS : " + e.getMessage().toString());
             }
         }
    
         return token;
     }
    
  8. In MainActivity.java aggiungere il metodo seguente alla classe MainActivity per gestire il clic del pulsante Invia notifica e inviare il messaggio di notifica push all'hub usando l'API REST predefinita.In MainActivity.java, add the following method to the MainActivity class to handle the Send Notification button click and send the push notification message to the hub by using the built-in REST API.

     /**
      * Send Notification button click handler. This method parses the
      * DefaultFullSharedAccess connection string and generates a SaS token. The
      * token is added to the Authorization header on the POST request to the
      * notification hub. The text in the editTextNotificationMessage control
      * is added as the JSON body for the request to add a GCM message to the hub.
      *
      * @param v
      */
     public void sendNotificationButtonOnClick(View v) {
         EditText notificationText = (EditText) findViewById(R.id.editTextNotificationMessage);
         final String json = "{\"data\":{\"message\":\"" + notificationText.getText().toString() + "\"}}";
    
         new Thread()
         {
             public void run()
             {
                 try
                 {
                     // Based on reference documentation...
                     // http://msdn.microsoft.com/library/azure/dn223273.aspx
                     ParseConnectionString(NotificationSettings.HubFullAccess);
                     URL url = new URL(HubEndpoint + NotificationSettings.HubName +
                             "/messages/?api-version=2015-01");
    
                     HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
    
                     try {
                         // POST request
                         urlConnection.setDoOutput(true);
    
                         // Authenticate the POST request with the SaS token
                         urlConnection.setRequestProperty("Authorization", 
                             generateSasToken(url.toString()));
    
                         // Notification format should be GCM
                         urlConnection.setRequestProperty("ServiceBusNotification-Format", "gcm");
    
                         // Include any tags
                         // Example below targets 3 specific tags
                         // Refer to : https://azure.microsoft.com/en-us/documentation/articles/notification-hubs-routing-tag-expressions/
                         // urlConnection.setRequestProperty("ServiceBusNotification-Tags", 
                         //        "tag1 || tag2 || tag3");
    
                         // Send notification message
                         urlConnection.setFixedLengthStreamingMode(json.length());
                         OutputStream bodyStream = new BufferedOutputStream(urlConnection.getOutputStream());
                         bodyStream.write(json.getBytes());
                         bodyStream.close();
    
                         // Get reponse
                         urlConnection.connect();
                         int responseCode = urlConnection.getResponseCode();
                         if ((responseCode != 200) && (responseCode != 201)) {
                             BufferedReader br = new BufferedReader(new InputStreamReader((urlConnection.getErrorStream())));
                             String line;
                             StringBuilder builder = new StringBuilder("Send Notification returned " +
                                     responseCode + " : ")  ;
                             while ((line = br.readLine()) != null) {
                                 builder.append(line);
                             }
    
                             ToastNotify(builder.toString());
                         }
                     } finally {
                         urlConnection.disconnect();
                     }
                 }
                 catch(Exception e)
                 {
                     if (isVisible) {
                         ToastNotify("Exception Sending Notification : " + e.getMessage().toString());
                     }
                 }
             }
         }.start();
     }
    

Testare l'appTesting your app

Notifiche push nell'emulatorePush notifications in the emulator

Per testare le notifiche push all'interno dell'emulatore, assicurarsi che l'immagine dell'emulatore supporti il livello Google API scelto per l'app.If you want to test push notifications inside an emulator, make sure that your emulator image supports the Google API level that you chose for your app. Se l'immagine non supporta le API di Google in modalità nativa verrà generata l'eccezione SERVICE_NOT_AVAILABLE.If your image doesn't support native Google APIs, you will end up with the SERVICE_NOT_AVAILABLE exception.

Verificare anche di avere aggiunto l'account Google all'emulatore in esecuzione in Impostazioni > Account.In addition to the above, ensure that you have added your Google account to your running emulator under Settings > Accounts. In caso contrario, i tentativi di registrazione con GCM potrebbero generare l'eccezione AUTHENTICATION_FAILED.Otherwise, your attempts to register with GCM may result in the AUTHENTICATION_FAILED exception.

Esecuzione dell'applicazioneRunning the application

  1. Eseguire l'app e notare l'ID registrazione segnalato per una registrazione riuscita.Run the app and notice that the registration ID is reported for a successful registration.

    Test in Android: registrazione di canali

  2. Immettere un messaggio di notifica da inviare a tutti i dispositivi Android registrati con l'hub.Enter a notification message to be sent to all Android devices that have registered with the hub.

    Test in Android: invio di un messaggio

  3. Premere Send Notification.Press Send Notification. Su tutti i dispositivi che eseguono l'app verrà visualizzata un'istanza di AlertDialog con il messaggio di notifica push.Any devices that have the app running will show an AlertDialog instance with the push notification message. I dispositivi che non eseguono l'app, ma che sono stati registrati in precedenza per le notifiche push, riceveranno una notifica in Android Notification Manager.Devices that don't have the app running but were previously registered for push notifications will receive a notification in the Android Notification Manager. Per visualizzarle, scorrere verso il basso dall'angolo superiore sinistro.Those can be viewed by swiping down from the upper-left corner.

    Test in Android: notifiche

Passaggi successiviNext steps

Come passaggio successivo, è consigliabile vedere l'esercitazione Uso di Hub di notifica di Azure per inviare notifiche agli utenti .We recommend the [Use Notification Hubs to push notifications to users] tutorial as the next step. Verrà illustrato come inviare notifiche da un back-end ASP.NET destinate a utenti specifici.It will show you how to send notifications from an ASP.NET backend using tags to target specific users.

Per segmentare gli utenti in base ai gruppi di interesse, vedere l'esercitazione Usare Hub di notifica per inviare le ultime notizie .If you want to segment your users by interest groups, check out the [Use Notification Hubs to send breaking news] tutorial.

Per altre informazioni generali sull'uso di Hub di notifica, vedere Hub di notifica di Azure.To learn more general information about Notification Hubs, see our [Notification Hubs Guidance].