Dodawanie powiadomień wypychanych do aplikacji systemu iOS

• Android
• Cordova
• iOS
• Windows
• Xamarin.Android
• Xamarin.iOS
• Xamarin.Forms

Omówienie

W tym samouczku dodasz powiadomienia wypychane do projektu szybkiego startu dla systemu iOS , aby powiadomienie wypychane było wysyłane do urządzenia za każdym razem, gdy rekord zostanie wstawiony.

Jeśli nie używasz pobranego projektu serwera szybkiego startu, potrzebny będzie pakiet rozszerzenia powiadomień wypychanych. Aby uzyskać więcej informacji, zobacz Work with the .NET backend server SDK for Azure Mobile Apps guide (Praca z zestawem SDK serwera zaplecza platformy .NET dla usługi Azure Mobile Apps ).

Symulator systemu iOS nie obsługuje powiadomień wypychanych. Potrzebujesz fizycznego urządzenia z systemem iOS i członkostwa w programie Apple Developer Program.

Konfigurowanie centrum powiadomień

Funkcja Mobile Apps Azure App Service używa usługi Azure Notification Hubs do wysyłania wypychań, dlatego skonfigurujesz centrum powiadomień dla aplikacji mobilnej.

1. W Azure Portal przejdź do usługi App Services, a następnie wybierz zaplecze aplikacji. W obszarze Ustawienia wybierz pozycję Wypychanie.

2. Aby dodać zasób centrum powiadomień do aplikacji, wybierz pozycję Połącz. Możesz utworzyć koncentrator lub połączyć się z istniejącym.

   

Teraz połączono centrum powiadomień z projektem zaplecza usługi Mobile Apps. Później skonfigurujesz to centrum powiadomień, aby nawiązać połączenie z systemem powiadomień platformy (PNS) w celu wypychania do urządzeń.

Rejestrowanie aplikacji na potrzeby powiadomień wypychanych

• Zarejestruj identyfikator aplikacji dla aplikacji. Utwórz jawny identyfikator aplikacji (a nie identyfikator aplikacji z symbolami wieloznacznymi) i w polu Identyfikator pakietu użyj dokładnego identyfikatora pakietu, który znajduje się w projekcie szybkiego startu Xcode. Ważne jest również, aby wybrać opcję Powiadomienia wypychane .
• Następnie , aby przygotować się do konfigurowania powiadomień wypychanych, utwórz certyfikat SSL "Programowanie" lub "Dystrybucja".

Konfigurowanie platformy Azure do wysyłania powiadomień wypychanych

1. Na komputerze Mac uruchom program Keychain Access. Na pasku nawigacyjnym po lewej stronie w obszarze Kategoria otwórz pozycję Moje certyfikaty. Znajdź certyfikat SSL pobrany w poprzedniej sekcji, a następnie ujawnij jego zawartość. Wybierz tylko certyfikat (nie wybieraj klucza prywatnego). Następnie wyeksportuj go.
2. W Azure Portal wybierz pozycję Przeglądaj wszystkie>usługi App Services. Następnie wybierz zaplecze usługi Mobile Apps.
3. W obszarze Ustawienia wybierz pozycję App Service Wypychanie. Następnie wybierz nazwę centrum powiadomień.
4. Przejdź do pozycji Apple Push Notification ServicesUpload Certificate (Przekazywanie certyfikatuusługi Apple Push Notification Services>). Przekaż plik p12, wybierając prawidłowy tryb (w zależności od tego, czy certyfikat SSL klienta z wcześniejszej wersji jest produkcyjny, czy piaskownica). Zapisz wszelkie zmiany.

Usługa jest teraz skonfigurowana do pracy z powiadomieniami wypychanymi w systemie iOS.

Aktualizowanie zaplecza w celu wysyłania powiadomień wypychanych

Zaplecze platformy .NET (C#):

1. W programie Visual Studio kliknij prawym przyciskiem myszy projekt serwera i kliknij polecenie Zarządzaj pakietami NuGet, wyszukaj polecenie Microsoft.Azure.NotificationHubs, a następnie kliknij przycisk Zainstaluj. Spowoduje to zainstalowanie biblioteki usługi Notification Hubs na potrzeby wysyłania powiadomień z zaplecza.

2. W projekcie programu Visual Studio zaplecza otwórz plik Controllers>TodoItemController.cs. W górnej części pliku dodaj następującą using instrukcję:

   using Microsoft.Azure.Mobile.Server.Config;
   using Microsoft.Azure.NotificationHubs;
   

3. Zastąp metodę PostTodoItem poniższym kodem:

   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);
   
       // iOS payload
       var appleNotificationPayload = "{\"aps\":{\"alert\":\"" + item.Text + "\"}}";
   
       try
       {
           // Send the push notification and log the results.
           var result = await hub.SendAppleNativeNotificationAsync(appleNotificationPayload);
   
           // 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. Opublikuj ponownie projekt serwera.

Wewnętrzna baza danych Node.js:

1. Skonfiguruj projekt zaplecza.

2. Zastąp skrypt tabeli todoitem.js następującym kodem:

   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();
   
   // When adding record, send a push notification via APNS
   table.insert(function (context) {
       // For details of the Notification Hubs JavaScript SDK, 
       // see https://aka.ms/nodejshubs
       logger.info('Running TodoItem.insert');
   
       // Create a payload that contains the new item Text.
       var payload = "{\"aps\":{\"alert\":\"" + context.item.text + "\"}}";
   
       // Execute the insert; Push as a post-execute action when results are returned as a Promise.
       return context.execute()
           .then(function (results) {
               // Only do the push if configured
               if (context.push) {
                   context.push.apns.send(null, payload, function (error) {
                       if (error) {
                           logger.error('Error while sending push notification: ', error);
                       } else {
                           logger.info('Push notification sent successfully!');
                       }
                   });
               }
               return results;
           })
           .catch(function (error) {
               logger.error('Error while running context.execute: ', error);
           });
   });
   
   module.exports = table;
   

3. Podczas edytowania pliku na komputerze lokalnym ponownie opublikuj projekt serwera.

Dodawanie powiadomień wypychanych do aplikacji

Objective-C:

1. W pliku QSAppDelegate.m zaimportuj zestaw SDK systemu iOS i QSTodoService.h:

   #import <MicrosoftAzureMobile/MicrosoftAzureMobile.h>
   #import "QSTodoService.h"
   

2. W didFinishLaunchingWithOptions pliku QSAppDelegate.m wstaw następujące wiersze bezpośrednio przed return YES;:

   UIUserNotificationSettings* notificationSettings = [UIUserNotificationSettings settingsForTypes:UIUserNotificationTypeAlert | UIUserNotificationTypeBadge | UIUserNotificationTypeSound categories:nil];
   [[UIApplication sharedApplication] registerUserNotificationSettings:notificationSettings];
   [[UIApplication sharedApplication] registerForRemoteNotifications];
   

3. W pliku QSAppDelegate.m dodaj następujące metody obsługi. Aplikacja jest teraz aktualizowana w celu obsługi powiadomień wypychanych.

   // Registration with APNs is successful
   - (void)application:(UIApplication *)application
   didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
   
       QSTodoService *todoService = [QSTodoService defaultService];
       MSClient *client = todoService.client;
   
       [client.push registerDeviceToken:deviceToken completion:^(NSError *error) {
           if (error != nil) {
               NSLog(@"Error registering for notifications: %@", error);
           }
       }];
   }
   
   // Handle any failure to register
   - (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:
   (NSError *)error {
       NSLog(@"Failed to register for remote notifications: %@", error);
   }
   
   // Use userInfo in the payload to display an alert.
   - (void)application:(UIApplication *)application
           didReceiveRemoteNotification:(NSDictionary *)userInfo {
       NSLog(@"%@", userInfo);
   
       NSDictionary *apsPayload = userInfo[@"aps"];
       NSString *alertString = apsPayload[@"alert"];
   
       // Create alert with notification content.
       UIAlertController *alertController = [UIAlertController
                                       alertControllerWithTitle:@"Notification"
                                       message:alertString
                                       preferredStyle:UIAlertControllerStyleAlert];
   
       UIAlertAction *cancelAction = [UIAlertAction
                                       actionWithTitle:NSLocalizedString(@"Cancel", @"Cancel")
                                       style:UIAlertActionStyleCancel
                                       handler:^(UIAlertAction *action)
                                       {
                                           NSLog(@"Cancel");
                                       }];
   
       UIAlertAction *okAction = [UIAlertAction
                                   actionWithTitle:NSLocalizedString(@"OK", @"OK")
                                   style:UIAlertActionStyleDefault
                                   handler:^(UIAlertAction *action)
                                   {
                                       NSLog(@"OK");
                                   }];
   
       [alertController addAction:cancelAction];
       [alertController addAction:okAction];
   
       // Get current view controller.
       UIViewController *currentViewController = [[[[UIApplication sharedApplication] delegate] window] rootViewController];
       while (currentViewController.presentedViewController)
       {
           currentViewController = currentViewController.presentedViewController;
       }
   
       // Display alert.
       [currentViewController presentViewController:alertController animated:YES completion:nil];
   
   }
   

Swift:

1. Dodaj plik ClientManager.swift z następującą zawartością. Zastąp element %AppUrl% adresem URL zaplecza aplikacji mobilnej platformy Azure.

   class ClientManager {
       static let sharedClient = MSClient(applicationURLString: "%AppUrl%")
   }
   

2. W pliku ToDoTableViewController.swift zastąp let client wiersz, który inicjuje MSClient element na następujący wiersz:

   let client = ClientManager.sharedClient
   

3. W pliku AppDelegate.swift zastąp treść w func application następujący sposób:

   func application(application: UIApplication,
       didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
       application.registerUserNotificationSettings(
           UIUserNotificationSettings(forTypes: [.Alert, .Badge, .Sound],
               categories: nil))
       application.registerForRemoteNotifications()
       return true
   }
   

4. W pliku AppDelegate.swift dodaj następujące metody obsługi. Aplikacja jest teraz aktualizowana w celu obsługi powiadomień wypychanych.

   func application(application: UIApplication,
       didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {
       ClientManager.sharedClient.push?.registerDeviceToken(deviceToken) { error in
           print("Error registering for notifications: ", error?.description)
       }
   }
   
   func application(application: UIApplication,
       didFailToRegisterForRemoteNotificationsWithError error: NSError) {
       print("Failed to register for remote notifications: ", error.description)
   }
   
   func application(application: UIApplication,
       didReceiveRemoteNotification userInfo: [NSObject: AnyObject]) {
   
       print(userInfo)
   
       let apsNotification = userInfo["aps"] as? NSDictionary
       let apsString       = apsNotification?["alert"] as? String
   
       let alert = UIAlertController(title: "Alert", message: apsString, preferredStyle: .Alert)
       let okAction = UIAlertAction(title: "OK", style: .Default) { _ in
           print("OK")
       }
       let cancelAction = UIAlertAction(title: "Cancel", style: .Default) { _ in
           print("Cancel")
       }
   
       alert.addAction(okAction)
       alert.addAction(cancelAction)
   
       var currentViewController = self.window?.rootViewController
       while currentViewController?.presentedViewController != nil {
           currentViewController = currentViewController?.presentedViewController
       }
   
       currentViewController?.presentViewController(alert, animated: true) {}
   
   }
   

Testowanie powiadomień wypychanych

• W programie Xcode naciśnij pozycję Uruchom i uruchom aplikację na urządzeniu z systemem iOS (pamiętaj, że wypychanie nie będzie działać w symulatorach). Kliknij przycisk OK , aby zaakceptować powiadomienia wypychane; to żądanie jest wykonywane po raz pierwszy podczas uruchamiania aplikacji.
• W aplikacji dodaj nowy element i kliknij pozycję +.
• Sprawdź, czy odebrano powiadomienie, a następnie kliknij przycisk OK , aby odrzucić powiadomienie. Ten samouczek został ukończony pomyślnie.

Więcej

• Szablony zapewniają elastyczność wysyłania wypychań międzyplatformowych i zlokalizowanych wypychań. Jak używać biblioteki klienta systemu iOS dla usługi Azure Mobile Apps , pokazuje, jak zarejestrować szablony.