Uso di Hub di notifica di Azure per inviare notifiche agli utenti per iOS con back-end .NET

Panoramica

Il supporto per le notifiche push in Azure consente di accedere a un'infrastruttura push facile da usare, multipiattaforma e con scalabilità orizzontale, che semplifica considerevolmente l'implementazione delle notifiche push sia per le applicazioni consumer sia per quelle aziendali per piattaforme mobili. In questa esercitazione viene illustrato come usare Hub di notifica di Azure per inviare notifiche push a un utente specifico dell'app su un dispositivo specifico. Per autenticare i client e generare le notifiche viene usato un back-end di API Web ASP.NET, come illustrato nell'argomento Registering from your app backend (Registrazione dal back-end dell'app).

Nota

In questa esercitazione si presuppone che l'utente abbia creato e configurato l'hub di notifica come descritto in Introduzione ad Hub di notifica (iOS). È inoltre propedeutica all'esercitazione Push sicuro (iOS) . Se si desidera usare le app per dispositivi mobili come servizio back-end, vedere Introduzione alle app per dispositivi mobili con notifiche push.

Creare il progetto di API Web

Un nuovo back-end WebAPI ASP.NET verrà creato nelle sezioni che seguono e avrà tre scopi principali:

  1. Autenticazione dei client: in seguito verrà aggiunto un gestore di messaggi per autenticare le richieste client e associare l'utente alla richiesta.
  2. Registrazioni delle notifiche client: in seguito si aggiungerà un controllo per gestire le nuove registrazioni in modo che un dispositivo cliente riceva le notifiche. Il nome utente autenticato verrà aggiunto automaticamente alla registrazione come tag.
  3. Invio di notifiche ai client: in seguito si aggiungerà anche un controller per fornire all'utente un modo per attivare un push sicuro ai dispositivi e ai client associati al tag.

I passaggi seguenti mostrano come creare un nuovo back-end WebAPI ASP.NET:

Nota

Importante: se si usa Visual Studio 2015 o versione precedente, prima di procedere con l'esercitazione verificare di aver installato la versione più recente di Gestione pacchetti NuGet. A questo scopo, avviare Visual Studio. Scegliere Estensioni e aggiornamenti dal menu Strumenti. Cercare Gestione pacchetti NuGet per la versione di Visual Studio e verificare che sia installata la versione più recente. In caso contrario, disinstallare e quindi reinstallare Gestione pacchetti NuGet.

Nota

Assicurarsi che sia installato Visual Studio Azure SDK per la distribuzione del sito Web.

  1. Avviare Visual Studio o Visual Studio Express. Fare clic su Esplora server e accedere all'account Azure. Per la creazione delle risorse del sito Web nell'account, in Visual Studio è necessario eseguire l'accesso.
  2. In Visual Studio fare clic su File, Nuovo e quindi Progetto, espandere Modelli e Visual C#, quindi fare clic su Web e Applicazione Web ASP.NET, digitare il nome AppBackend e infine fare clic su OK.

  3. Nella finestra di dialogo Nuovo progetto ASP.NET fare clic su API Web e quindi su OK.

  4. Nella finestra di dialogo Configura app Web di Microsoft Azure scegliere una sottoscrizione e un piano di servizio app già creato. È inoltre possibile scegliere Crea un nuovo piano di servizio app e crearne uno dalla finestra di dialogo. Per questa esercitazione non è necessario disporre di un database. Dopo aver selezionato il piano di servizio app, fare clic su OK per creare il progetto.

Autenticazione di client al back-end WebAPI

In questa sezione si creerà una nuova classe del gestore di messaggi denominata AuthenticationTestHandler per il nuovo back-end. Questa classe è derivata da DelegatingHandler e viene aggiunta come gestore di messaggi per poter elaborare tutte le richieste in arrivo nel back-end.

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto AppBackend, scegliere Aggiungi e quindi fare clic su Classe. Assegnare alla nuova classe il nome AuthenticationTestHandler.cs e fare clic su Aggiungi per generarla. Questa classe viene usata per semplicità per autenticare gli utenti mediante l' autenticazione di base . Tenere presente che l'app può usare qualsiasi schema di autenticazione.
  2. In AuthenticationTestHandler.cs aggiungere le istruzioni using seguenti:

     using System.Net.Http;
     using System.Threading;
     using System.Security.Principal;
     using System.Net;
     using System.Text;
     using System.Threading.Tasks;
    
  3. In AuthenticationTestHandler.cs sostituire la definizione di classe AuthenticationTestHandler con il codice seguente:

    Questo gestore autorizza la richiesta quando le tre seguenti condizioni sono tutte vere:

    • La richiesta include un'intestazione Autorizzazione .
    • La richiesta usa l'autenticazione di base .
    • La stringa del nome utente corrisponde alla stringa della password.

      In caso contrario, la richiesta verrà rifiutata. Non si tratta di un vero approccio di autenticazione e autorizzazione. È un esempio molto semplice per questa esercitazione.

      Se il messaggio di richiesta viene autenticato e autorizzato da AuthenticationTestHandler, l'utente di autenticazione di base verrà associato alla richiesta corrente in HttpContext. Le informazioni utente in HttpContext verranno usate da un altro controller (RegisterController) in un secondo momento per aggiungere un tag per la richiesta di registrazione della notifica.

      public class AuthenticationTestHandler : DelegatingHandler { protected override Task SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { var authorizationHeader = request.Headers.GetValues("Authorization").First();

            if (authorizationHeader != null && authorizationHeader
                .StartsWith("Basic ", StringComparison.InvariantCultureIgnoreCase))
            {
                string authorizationUserAndPwdBase64 =
                    authorizationHeader.Substring("Basic ".Length);
                string authorizationUserAndPwd = Encoding.Default
                    .GetString(Convert.FromBase64String(authorizationUserAndPwdBase64));
                string user = authorizationUserAndPwd.Split(':')[0];
                string password = authorizationUserAndPwd.Split(':')[1];
      
                if (verifyUserAndPwd(user, password))
                {
                    // Attach the new principal object to the current HttpContext object
                    HttpContext.Current.User =
                        new GenericPrincipal(new GenericIdentity(user), new string[0]);
                    System.Threading.Thread.CurrentPrincipal =
                        System.Web.HttpContext.Current.User;
                }
                else return Unauthorized();
            }
            else return Unauthorized();
      
            return base.SendAsync(request, cancellationToken);
        }
      
        private bool verifyUserAndPwd(string user, string password)
        {
            // This is not a real authentication scheme.
            return user == password;
        }
      
        private Task<HttpResponseMessage> Unauthorized()
        {
            var response = new HttpResponseMessage(HttpStatusCode.Forbidden);
            var tsc = new TaskCompletionSource<HttpResponseMessage>();
            tsc.SetResult(response);
            return tsc.Task;
        }
      

      }

      Nota

      Nota sulla sicurezza: la classe AuthenticationTestHandler non fornisce un'effettiva autenticazione. Viene usata solo per imitare l'autenticazione di base e non è sicura. È necessario implementare un meccanismo di autenticazione sicuro nelle applicazioni e nei servizi di produzione.

  4. Aggiungere il codice seguente alla fine del metodo Register nella classe App_Start/WebApiConfig.cs per registrare il gestore di messaggi:

     config.MessageHandlers.Add(new AuthenticationTestHandler());
    
  5. Salvare le modifiche.

Registrazione per le notifiche tramite il back-end WebAPI

In questa sezione si aggiungerà un nuovo controller al back-end WebAPI per gestire le richieste per la registrazione di un utente e un dispositivo per le notifiche tramite la libreria client per gli hub di notifica. Il controller aggiungerà un tag user per l'utente che è stato autenticato e collegato a HttpContext da AuthenticationTestHandler. Il tag avrà il formato della stringa, "username:<actual username>".

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto AppBackend e quindi scegliere Gestisci pacchetti NuGet.
  2. Sul lato sinistro fare clic su Online e cercare Microsoft.Azure.NotificationHubs nella casella di ricerca.
  3. Nell'elenco risultati fare clic su Hub di notifica di Microsoft Azure e quindi su Installa. Completare l'installazione e chiudere la finestra di Gestione pacchetti NuGet.

    Verrà aggiunto un riferimento all’SDK dell’Hub di notifica di Azure mediante il pacchetto NuGet Microsoft.Azure.NotificationHubs.

  4. Ora verrà creato un nuovo file della classe che rappresenta la connessione con l'hub di notifica usato per inviare le notifiche. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla cartella Modelli, scegliere Aggiungi e quindi fare clic su Classe. Assegnare alla nuova classe il nome Notifications.cs e quindi fare clic su Aggiungi per generarla.

  5. In Notifications.cs aggiungere l'istruzione using seguente all'inizio del file:

     using Microsoft.Azure.NotificationHubs;
    
  6. Sostituire la definizione di classe Notifications con il codice seguente e assicurarsi di sostituire i due segnaposto con la stringa di connessione (con accesso completo) per l'hub di notifica e con il nome dell'hub (disponibile nel portale di Azure classico):

     public class Notifications
     {
         public static Notifications Instance = new Notifications();
    
         public NotificationHubClient Hub { get; set; }
    
         private Notifications() {
             Hub = NotificationHubClient.CreateClientFromConnectionString("<your hub's DefaultFullSharedAccessSignature>", 
                                                                          "<hub name>");
         }
     }
    
  7. Verrà quindi creato un nuovo controller denominato RegisterController. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla cartella Controller, scegliere Aggiungi e quindi fare clic su Controller. Fare clic sull'elemento Controller Web API 2 - Vuoto e quindi su Aggiungi. Assegnare alla nuova classe il nome RegisterController e quindi fare di nuovo clic su Aggiungi per generare il controller.

  8. In RegisterController.cs aggiungere le istruzioni using seguenti:

     using Microsoft.Azure.NotificationHubs;
     using Microsoft.Azure.NotificationHubs.Messaging;
     using AppBackend.Models;
     using System.Threading.Tasks;
     using System.Web;
    
  9. Aggiungere il codice seguente all'interno della definizione di classe RegisterController . Si noti che in questo codice viene aggiunto un tag user per l'utente associato a HttpContext. L'utente è stato autenticato e associato a HttpContext dal filtro messaggi aggiunto, AuthenticationTestHandler. È anche possibile aggiungere controlli facoltativi per verificare che l'utente disponga dei diritti per la registrazione per i tag richiesti.

     private NotificationHubClient hub;
    
     public RegisterController()
     {
         hub = Notifications.Instance.Hub;
     }
    
     public class DeviceRegistration
     {
         public string Platform { get; set; }
         public string Handle { get; set; }
         public string[] Tags { get; set; }
     }
    
     // POST api/register
     // This creates a registration id
     public async Task<string> Post(string handle = null)
     {
         string newRegistrationId = null;
    
         // make sure there are no existing registrations for this push handle (used for iOS and Android)
         if (handle != null)
         {
             var registrations = await hub.GetRegistrationsByChannelAsync(handle, 100);
    
             foreach (RegistrationDescription registration in registrations)
             {
                 if (newRegistrationId == null)
                 {
                     newRegistrationId = registration.RegistrationId;
                 }
                 else
                 {
                     await hub.DeleteRegistrationAsync(registration);
                 }
             }
         }
    
         if (newRegistrationId == null) 
             newRegistrationId = await hub.CreateRegistrationIdAsync();
    
         return newRegistrationId;
     }
    
     // PUT api/register/5
     // This creates or updates a registration (with provided channelURI) at the specified id
     public async Task<HttpResponseMessage> Put(string id, DeviceRegistration deviceUpdate)
     {
         RegistrationDescription registration = null;
         switch (deviceUpdate.Platform)
         {
             case "mpns":
                 registration = new MpnsRegistrationDescription(deviceUpdate.Handle);
                 break;
             case "wns":
                 registration = new WindowsRegistrationDescription(deviceUpdate.Handle);
                 break;
             case "apns":
                 registration = new AppleRegistrationDescription(deviceUpdate.Handle);
                 break;
             case "gcm":
                 registration = new GcmRegistrationDescription(deviceUpdate.Handle);
                 break;
             default:
                 throw new HttpResponseException(HttpStatusCode.BadRequest);
         }
    
         registration.RegistrationId = id;
         var username = HttpContext.Current.User.Identity.Name;
    
         // add check if user is allowed to add these tags
         registration.Tags = new HashSet<string>(deviceUpdate.Tags);
         registration.Tags.Add("username:" + username);
    
         try
         {
             await hub.CreateOrUpdateRegistrationAsync(registration);
         }
         catch (MessagingException e)
         {
             ReturnGoneIfHubResponseIsGone(e);
         }
    
         return Request.CreateResponse(HttpStatusCode.OK);
     }
    
     // DELETE api/register/5
     public async Task<HttpResponseMessage> Delete(string id)
     {
         await hub.DeleteRegistrationAsync(id);
         return Request.CreateResponse(HttpStatusCode.OK);
     }
    
     private static void ReturnGoneIfHubResponseIsGone(MessagingException e)
     {
         var webex = e.InnerException as WebException;
         if (webex.Status == WebExceptionStatus.ProtocolError)
         {
             var response = (HttpWebResponse)webex.Response;
             if (response.StatusCode == HttpStatusCode.Gone)
                 throw new HttpRequestException(HttpStatusCode.Gone.ToString());
         }
     }
    
  10. Salvare le modifiche.

Invio di notifiche dal back-end WebAPI

In questa sezione si aggiungerà un nuovo controller che espone un modo per consentire ai dispositivi client di inviare una notifica in base al tag username usando la libreria di gestione del servizio Hub di notifica di Azure nel back-end WebAPI ASP.NET.

  1. Creare un altro nuovo controller denominato NotificationsController. Crearlo seguendo la stessa procedura usata per creare RegisterController nella sezione precedente.
  2. In NotificationsController.cs aggiungere le istruzioni using seguenti:

     using AppBackend.Models;
     using System.Threading.Tasks;
     using System.Web;
    
  3. Aggiungere il codice seguente alla classe NotificationsController .

    Questo codice invia un tipo di notifica basato sul parametro pns (Platform Notification Service). Il valore to_tag viene usato per impostare il tag username nel messaggio. Questo tag deve corrispondere a un tag username di una registrazione dell'hub di notifica attiva. Il messaggio di notifica viene estratto dal corpo della richiesta POST ed è formattato per il PNS di destinazione.

    A seconda del PNS (Platform Notification Service) usato dai dispositivi supportati per ricevere le notifiche, sono supportate notifiche diverse con formati diversi. Ad esempio nei dispositivi Windows è possibile usare una notifica di tipo avviso popup con WNS che non è supportata direttamente da un altro PNS. Il back-end deve pertanto formattare la notifica come una notifica supportata per il PNS dei dispositivi che si intende supportare. Usare quindi l'API di invio appropriata per la classe NotificationHubClient

     public async Task<HttpResponseMessage> Post(string pns, [FromBody]string message, string to_tag)
     {
         var user = HttpContext.Current.User.Identity.Name;
         string[] userTag = new string[2];
         userTag[0] = "username:" + to_tag;
         userTag[1] = "from:" + user;
    
         Microsoft.Azure.NotificationHubs.NotificationOutcome outcome = null;
         HttpStatusCode ret = HttpStatusCode.InternalServerError;
    
         switch (pns.ToLower())
         {
             case "wns":
                 // Windows 8.1 / Windows Phone 8.1
                 var toast = @"<toast><visual><binding template=""ToastText01""><text id=""1"">" + 
                             "From " + user + ": " + message + "</text></binding></visual></toast>";
                 outcome = await Notifications.Instance.Hub.SendWindowsNativeNotificationAsync(toast, userTag);
                 break;
             case "apns":
                 // iOS
                 var alert = "{\"aps\":{\"alert\":\"" + "From " + user + ": " + message + "\"}}";
                 outcome = await Notifications.Instance.Hub.SendAppleNativeNotificationAsync(alert, userTag);
                 break;
             case "gcm":
                 // Android
                 var notif = "{ \"data\" : {\"message\":\"" + "From " + user + ": " + message + "\"}}";
                 outcome = await Notifications.Instance.Hub.SendGcmNativeNotificationAsync(notif, userTag);
                 break;
         }
    
         if (outcome != null)
         {
             if (!((outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Abandoned) ||
                 (outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Unknown)))
             {
                 ret = HttpStatusCode.OK;
             }
         }
    
         return Request.CreateResponse(ret);
     }
    
  4. Premere F5 per eseguire l'applicazione e verificare l'accuratezza del lavoro fino a questo punto. L'app dovrebbe avviare un Web browser e visualizzare la home page di ASP.NET.

Pubblicare il nuovo back-end WebAPId

  1. L'app verrà ora distribuita in un sito Web Azure in modo da renderla accessibile da tutti i dispositivi. Fare clic con il pulsante destro del mouse sul progetto AppBackend e scegliere Pubblica.
  2. Selezionare Servizio app di Microsoft Azure come destinazione di pubblicazione e quindi fare clic su Pubblica. Verrà visualizzata la finestra di dialogo Crea servizio app, che consente di creare tutte le risorse di Azure necessarie per eseguire l'app Web ASP.NET in Azure.

  3. Nella finestra di dialogo Crea servizio app selezionare l'account Azure. Fare clic su Modifica tipo e selezionare App Web. Mantenere il valore di Nome app Web assegnato e selezionare la sottoscrizione, il gruppo di risorse e il piano di servizio app. Fare clic su Crea.

  4. Prendere nota della proprietà URL sito nella scheda Riepilogo. Si farà riferimento a quest'URL come endpoint back-end più avanti in questa esercitazione. Fare clic su Pubblica.

  5. Al termine della procedura guidata, l'app Web ASP.NET viene pubblicata in Azure e avviata nel browser predefinito. L'applicazione sarà visibile in Servizi app di Azure.

L'URL usa il nome dell'app Web specificato in precedenza, con il formato http://.azurewebsites.net.

Modificare l'app per iOS

  1. Aprire l'app di visualizzazione Pagina singola creata nell'esercitazione Introduzione ad Hub di notifica (iOS) .

    Nota

    In questa sezione si presuppone che il progetto sia configurato con un nome di organizzazione vuoto. In caso contrario, sarà necessario anteporre il nome dell'organizzazione a tutti i nomi di classi.

  2. In Main.storyboard aggiungere i componenti illustrati nella schermata seguente dalla libreria di oggetti.

    • Nome utente: oggetto UITextField con testo segnaposto, Enter Username, immediatamente sotto l'etichetta per l'invio dei risultati e limitato dai margini sinistro e destro.
    • Password: oggetto UITextField con testo segnaposto, Enter Password, immediatamente sotto il campo di testo del nome utente e limitato dai margini sinistro e destro. Selezionare l'opzione Secure Text Entry in Attribute Inspector sotto Return Key.
    • Accesso: oggetto UIButton con etichetta immediatamente sotto il campo di testo della password; deselezionare l'opzione Abilitato in Attributes Inspector sotto Control-Content.
    • WNS: etichetta e opzione per consentire l'invio della notifica al servizio di notifica Windows se è stato configurato nell'hub. Vedere l'esercitazione Introduzione a Windows.
    • GCM: etichetta e opzione per consentire l'invio della notifica a Google Cloud Messaging se è stato configurato nell'hub. Vedere l'esercitazione Introduzione ad Android .
    • APNS: etichetta e opzione per consentire l'invio della notifica al servizio di notifica della piattaforma di Apple.
    • Nome utente del destinatario: oggetto UITextField con testo segnaposto, Recipient username tag, immediatamente sotto l'etichetta GCM e limitato dai margini sinistro e destro.

      Alcuni componenti sono stati aggiunti nell'esercitazione Introduzione ad Hub di notifica (iOS) esercitazione.

  3. CTRL dai componenti nella visualizzazione a ViewController.h e aggiungere questi nuovi outlet.

     @property (weak, nonatomic) IBOutlet UITextField *UsernameField;
     @property (weak, nonatomic) IBOutlet UITextField *PasswordField;
     @property (weak, nonatomic) IBOutlet UITextField *RecipientField;
     @property (weak, nonatomic) IBOutlet UITextField *NotificationField;
    
     // Used to enable the buttons on the UI
     @property (weak, nonatomic) IBOutlet UIButton *LogInButton;
     @property (weak, nonatomic) IBOutlet UIButton *SendNotificationButton;
    
     // Used to enabled sending notifications across platforms
     @property (weak, nonatomic) IBOutlet UISwitch *WNSSwitch;
     @property (weak, nonatomic) IBOutlet UISwitch *GCMSwitch;
     @property (weak, nonatomic) IBOutlet UISwitch *APNSSwitch;
    
     - (IBAction)LogInAction:(id)sender;
    
  4. In ViewController.h aggiungere l'elemento #define seguente sotto le istruzioni di importazione. Sostituire il segnaposto > con l'URL di destinazione usato per distribuire il back-end dell'app nella sezione precedente. Ad esempio, http://you_backend.azurewebsites.net.

     #define BACKEND_ENDPOINT @"<Enter Your Backend Endpoint>"
    
  5. Nel progetto creare una nuova classe Cocoa Touch denominata RegisterClient da usare come interfaccia con il back-end ASP.NET creato. Creare la classe che eredita da NSObject. Aggiungere quindi il codice seguente in RegisterClient.h.

     @interface RegisterClient : NSObject
    
     @property (strong, nonatomic) NSString* authenticationHeader;
    
     -(void) registerWithDeviceToken:(NSData*)token tags:(NSSet*)tags
         andCompletion:(void(^)(NSError*))completion;
    
     -(instancetype) initWithEndpoint:(NSString*)Endpoint;
    
     @end
    
  6. In RegisterClient.m aggiornare la sezione @interface :

     @interface RegisterClient ()
    
     @property (strong, nonatomic) NSURLSession* session;
     @property (strong, nonatomic) NSURLSession* endpoint;
    
     -(void) tryToRegisterWithDeviceToken:(NSData*)token tags:(NSSet*)tags retry:(BOOL)retry
                 andCompletion:(void(^)(NSError*))completion;
     -(void) retrieveOrRequestRegistrationIdWithDeviceToken:(NSString*)token
                 completion:(void(^)(NSString*, NSError*))completion;
     -(void) upsertRegistrationWithRegistrationId:(NSString*)registrationId deviceToken:(NSString*)token
                 tags:(NSSet*)tags andCompletion:(void(^)(NSURLResponse*, NSError*))completion;
    
     @end
    
  7. Sostituire la sezione @implementation in RegisterClient.m con il codice seguente.

     @implementation RegisterClient
    
     // Globals used by RegisterClient
     NSString *const RegistrationIdLocalStorageKey = @"RegistrationId";
    
     -(instancetype) initWithEndpoint:(NSString*)Endpoint
     {
         self = [super init];
         if (self) {
             NSURLSessionConfiguration* config = [NSURLSessionConfiguration defaultSessionConfiguration];
             _session = [NSURLSession sessionWithConfiguration:config delegate:nil delegateQueue:nil];
             _endpoint = Endpoint;
         }
         return self;
     }
    
     -(void) registerWithDeviceToken:(NSData*)token tags:(NSSet*)tags
                 andCompletion:(void(^)(NSError*))completion
     {
         [self tryToRegisterWithDeviceToken:token tags:tags retry:YES andCompletion:completion];
     }
    
     -(void) tryToRegisterWithDeviceToken:(NSData*)token tags:(NSSet*)tags retry:(BOOL)retry
                 andCompletion:(void(^)(NSError*))completion
     {
         NSSet* tagsSet = tags?tags:[[NSSet alloc] init];
    
         NSString *deviceTokenString = [[token description]
             stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"<>"]];
         deviceTokenString = [[deviceTokenString stringByReplacingOccurrencesOfString:@" " withString:@""]
                                 uppercaseString];
    
         [self retrieveOrRequestRegistrationIdWithDeviceToken: deviceTokenString
             completion:^(NSString* registrationId, NSError *error) {
             NSLog(@"regId: %@", registrationId);
             if (error) {
                 completion(error);
                 return;
             }
    
             [self upsertRegistrationWithRegistrationId:registrationId deviceToken:deviceTokenString
                 tags:tagsSet andCompletion:^(NSURLResponse * response, NSError *error) {
                 if (error) {
                     completion(error);
                     return;
                 }
    
                 NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*)response;
                 if (httpResponse.statusCode == 200) {
                     completion(nil);
                 } else if (httpResponse.statusCode == 410 && retry) {
                     [self tryToRegisterWithDeviceToken:token tags:tags retry:NO andCompletion:completion];
                 } else {
                     NSLog(@"Registration error with response status: %ld", (long)httpResponse.statusCode);
    
                     completion([NSError errorWithDomain:@"Registration" code:httpResponse.statusCode
                                 userInfo:nil]);
                 }
    
             }];
         }];
     }
    
     -(void) upsertRegistrationWithRegistrationId:(NSString*)registrationId deviceToken:(NSData*)token
                 tags:(NSSet*)tags andCompletion:(void(^)(NSURLResponse*, NSError*))completion
     {
         NSDictionary* deviceRegistration = @{@"Platform" : @"apns", @"Handle": token,
                                                 @"Tags": [tags allObjects]};
         NSData* jsonData = [NSJSONSerialization dataWithJSONObject:deviceRegistration
                             options:NSJSONWritingPrettyPrinted error:nil];
    
         NSLog(@"JSON registration: %@", [[NSString alloc] initWithData:jsonData
                                             encoding:NSUTF8StringEncoding]);
    
         NSString* endpoint = [NSString stringWithFormat:@"%@/api/register/%@", _endpoint,
                                 registrationId];
         NSURL* requestURL = [NSURL URLWithString:endpoint];
         NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:requestURL];
         [request setHTTPMethod:@"PUT"];
         [request setHTTPBody:jsonData];
         NSString* authorizationHeaderValue = [NSString stringWithFormat:@"Basic %@",
                                                 self.authenticationHeader];
         [request setValue:authorizationHeaderValue forHTTPHeaderField:@"Authorization"];
         [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
    
         NSURLSessionDataTask* dataTask = [self.session dataTaskWithRequest:request
             completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
         {
             if (!error)
             {
                 completion(response, error);
             }
             else
             {
                 NSLog(@"Error request: %@", error);
                 completion(nil, error);
             }
         }];
         [dataTask resume];
     }
    
     -(void) retrieveOrRequestRegistrationIdWithDeviceToken:(NSString*)token
                 completion:(void(^)(NSString*, NSError*))completion
     {
         NSString* registrationId = [[NSUserDefaults standardUserDefaults]
                                     objectForKey:RegistrationIdLocalStorageKey];
    
         if (registrationId)
         {
             completion(registrationId, nil);
             return;
         }
    
         // request new one & save
         NSURL* requestURL = [NSURL URLWithString:[NSString stringWithFormat:@"%@/api/register?handle=%@",
                                 _endpoint, token]];
         NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:requestURL];
         [request setHTTPMethod:@"POST"];
         NSString* authorizationHeaderValue = [NSString stringWithFormat:@"Basic %@",
                                                 self.authenticationHeader];
         [request setValue:authorizationHeaderValue forHTTPHeaderField:@"Authorization"];
    
         NSURLSessionDataTask* dataTask = [self.session dataTaskWithRequest:request
             completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
         {
             NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*) response;
             if (!error && httpResponse.statusCode == 200)
             {
                 NSString* registrationId = [[NSString alloc] initWithData:data
                     encoding:NSUTF8StringEncoding];
    
                 // remove quotes
                 registrationId = [registrationId substringWithRange:NSMakeRange(1,
                                     [registrationId length]-2)];
    
                 [[NSUserDefaults standardUserDefaults] setObject:registrationId
                     forKey:RegistrationIdLocalStorageKey];
                 [[NSUserDefaults standardUserDefaults] synchronize];
    
                 completion(registrationId, nil);
             }
             else
             {
                 NSLog(@"Error status: %ld, request: %@", (long)httpResponse.statusCode, error);
                 if (error)
                     completion(nil, error);
                 else {
                     completion(nil, [NSError errorWithDomain:@"Registration" code:httpResponse.statusCode
                                 userInfo:nil]);
                 }
             }
         }];
         [dataTask resume];
     }
    
     @end
    

    Il codice riportato sopra implementa la logica illustrata nell'articolo di istruzioni Registrazione dal back-end dell'app usando NSURLSession per eseguire chiamate REST al back-end dell'app e NSUserDefaults per archiviare in locale l'ID registrazione restituito dall'hub di notifica.

    Si noti che per il corretto funzionamento di questa classe è necessario che sia impostata la relativa proprietà authorizationHeader . Questa proprietà viene impostata tramite la classe ViewController dopo l'accesso.

  8. In ViewController.h aggiungere un'istruzione #import per RegisterClient.h. Aggiungere quindi una dichiarazione per il token del dispositivo e fare riferimento a un'istanza di RegisterClient nella sezione @interface:

     #import "RegisterClient.h"
    
     @property (strong, nonatomic) NSData* deviceToken;
     @property (strong, nonatomic) RegisterClient* registerClient;
    
  9. In ViewController.m aggiungere una dichiarazione di metodo privato nella sezione @interface :

     @interface ViewController () <UITextFieldDelegate, NSURLConnectionDataDelegate, NSXMLParserDelegate>
    
     // create the Authorization header to perform Basic authentication with your app back-end
     -(void) createAndSetAuthenticationHeaderWithUsername:(NSString*)username
                     AndPassword:(NSString*)password;
    
     @end
    
Nota

Il frammento seguente non è uno schema di autenticazione sicuro. È consigliabile sostituire l'implementazione di createAndSetAuthenticationHeaderWithUsername:AndPassword: con il meccanismo di autenticazione specifico che genera un token di autenticazione che deve essere usato dalla classe client di registrazione, ad esempio OAuth o Active Directory.

  1. Aggiungere quindi nella sezione @implementation di ViewController.m il codice seguente che aggiunge l'implementazione per l'impostazione del token del dispositivo e dell'intestazione di autenticazione.

     -(void) setDeviceToken: (NSData*) deviceToken
     {
         _deviceToken = deviceToken;
         self.LogInButton.enabled = YES;
     }
    
     -(void) createAndSetAuthenticationHeaderWithUsername:(NSString*)username
                     AndPassword:(NSString*)password;
     {
         NSString* headerValue = [NSString stringWithFormat:@"%@:%@", username, password];
    
         NSData* encodedData = [[headerValue dataUsingEncoding:NSUTF8StringEncoding] base64EncodedDataWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn];
    
         self.registerClient.authenticationHeader = [[NSString alloc] initWithData:encodedData
                                                     encoding:NSUTF8StringEncoding];
     }
    
     -(BOOL)textFieldShouldReturn:(UITextField *)textField
     {
         [textField resignFirstResponder];
         return YES;
     }
    

    Si noti come impostando il token del dispositivo viene abilitato il pulsante di accesso. Questo dipende dal fatto che, nell'ambito dell'azione di accesso, il controller di visualizzazione esegue la registrazione per le notifiche push con il back-end dell'app. L'azione di accesso deve quindi essere accessibile solo dopo che il token del dispositivo è stato correttamente configurato. È possibile separare l'accesso dalla registrazione push, purché la prima azione avvenga prima della seconda.

  2. In ViewController.m usare i frammenti di codice seguenti per implementare il metodo di azione per il pulsante Log In e un metodo per inviare il messaggio di notifica con il back-end ASP.NET.

    - (IBAction)LogInAction:(id)sender {   // create authentication header and set it in register client   NSString* username = self.UsernameField.text;   NSString* password = self.PasswordField.text;
    
        [self createAndSetAuthenticationHeaderWithUsername:username AndPassword:password];
    
        __weak ViewController* selfie = self;   [self.registerClient registerWithDeviceToken:self.deviceToken tags:nil       andCompletion:^(NSError* error) {       if (!error) {           dispatch_async(dispatch_get_main_queue(),           ^{               selfie.SendNotificationButton.enabled = YES;               [self MessageBox:@"Success" message:@"Registered successfully!"];           });       }   }]; }
    
     - (void)SendNotificationASPNETBackend:(NSString*)pns UsernameTag:(NSString*)usernameTag            Message:(NSString*)message {    NSURLSession* session = [NSURLSession        sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:nil        delegateQueue:nil];
    
         // Pass the pns and username tag as parameters with the REST URL to the ASP.NET backend    NSURL* requestURL = [NSURL URLWithString:[NSString        stringWithFormat:@"%@/api/notifications?pns=%@&to_tag=%@", BACKEND_ENDPOINT, pns,        usernameTag]];
    
         NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:requestURL];    [request setHTTPMethod:@"POST"];
    
         // Get the mock authenticationheader from the register client    NSString* authorizationHeaderValue = [NSString stringWithFormat:@"Basic %@",        self.registerClient.authenticationHeader];    [request setValue:authorizationHeaderValue forHTTPHeaderField:@"Authorization"];
    
         //Add the notification message body    [request setValue:@"application/json;charset=utf-8" forHTTPHeaderField:@"Content-Type"];    [request setHTTPBody:[message dataUsingEncoding:NSUTF8StringEncoding]];
    
         // Execute the send notification REST API on the ASP.NET Backend    NSURLSessionDataTask* dataTask = [session dataTaskWithRequest:request        completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)    {        NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*) response;        if (error || httpResponse.statusCode != 200)        {            NSString* status = [NSString stringWithFormat:@"Error Status for %@: %d\nError: %@\n",                                pns, httpResponse.statusCode, error];            dispatch_async(dispatch_get_main_queue(),            ^{                // Append text because all 3 PNS calls may also have information to view                [self.sendResults setText:[self.sendResults.text stringByAppendingString:status]];            });            NSLog(status);        }
    
             if (data != NULL)
             {
                 xmlParser = [[NSXMLParser alloc] initWithData:data];
                 [xmlParser setDelegate:self];
                 [xmlParser parse];
             }
         }];    [dataTask resume]; }
    
  3. Aggiornare l'azione per il pulsante Send Notification per usare il back-end ASP.NET e inviare a qualsiasi PNS abilitato da un'opzione.

     - (IBAction)SendNotificationMessage:(id)sender
     {
         //[self SendNotificationRESTAPI];
         [self SendToEnabledPlatforms];
     }
    
    -(void)SendToEnabledPlatforms
    {
        NSString* json = [NSString stringWithFormat:@"\"%@\"",self.notificationMessage.text];

        [self.sendResults setText:@""];

        if ([self.WNSSwitch isOn])
            [self SendNotificationASPNETBackend:@"wns" UsernameTag:self.RecipientField.text Message:json];

        if ([self.GCMSwitch isOn])
            [self SendNotificationASPNETBackend:@"gcm" UsernameTag:self.RecipientField.text Message:json];

        if ([self.APNSSwitch isOn])
            [self SendNotificationASPNETBackend:@"apns" UsernameTag:self.RecipientField.text Message:json];
    }
  1. Nella funzione ViewDidLoadaggiungere quanto segue per creare l'istanza di RegisterClient e impostare il delegato per i campi di testo.

    self.UsernameField.delegate = self;
    self.PasswordField.delegate = self;
    self.RecipientField.delegate = self;
    self.registerClient = [[RegisterClient alloc] initWithEndpoint:BACKEND_ENDPOINT];
    
  2. In AppDelegate.m rimuovere tutto il contenuto del metodo application:didRegisterForPushNotificationWithDeviceToken: e sostituirlo con il seguente per assicurarsi che il controller di visualizzazione contenga il token del dispositivo più recente recuperato dagli APN:

    // Add import to the top of the file
    #import "ViewController.h"
    
    - (void)application:(UIApplication *)application
                didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
    {
        ViewController* rvc = (ViewController*) self.window.rootViewController;
        rvc.deviceToken = deviceToken;
    }
    
  3. Infine in AppDelegate.mverificare che sia presente il metodo seguente:

    - (void)application:(UIApplication *)application didReceiveRemoteNotification: (NSDictionary *)userInfo {
        NSLog(@"%@", userInfo);
        [self MessageBox:@"Notification" message:[[userInfo objectForKey:@"aps"] valueForKey:@"alert"]];
    }
    

Testare l'applicazione

  1. In XCode eseguire l'app su un dispositivo iOS fisico (le notifiche push non funzioneranno nel simulatore).
  2. Nell'interfaccia utente dell'app per iOS immettere un nome utente e una password. Può trattarsi di qualsiasi stringa, ma devono avere entrambi lo stesso valore di stringa. Quindi fare clic su Log In.

  3. Verrà visualizzata una finestra popup che informa che la registrazione è stata completata. Fare clic su OK.

  4. Nel campo di testo *Recipient username tag (Tag nome utente destinatario) immettere il tag del nome utente usato con la registrazione da un altro dispositivo.
  5. Immettere un messaggio di notifica e fare clic su Send Notification. Solo i dispositivi che hanno una registrazione con il tag del nome utente del destinatario riceveranno il messaggio di notifica. Viene inviato solo a tali utenti.