Otrzymuj powiadomienia push, gdy aplikacja jest na pierwszym planie iOS

Korzystam z usługi powiadomień wypychanych w mojej aplikacji. Gdy aplikacja jest w tle, widzę powiadomienie na ekranie powiadomień (ekran wyświetlany po przesunięciu w dół od góry urządzenia iOS). Ale jeśli aplikacja jest na pierwszym planie, metoda delegowania

- (void)application:(UIApplication*)application didReceiveRemoteNotification:(NSDictionary*)userInfo

jest wywoływany, ale powiadomienie nie jest wyświetlane na ekranie powiadomień.

Chcę wyświetlać powiadomienia na ekranie powiadomień niezależnie od tego, czy aplikacja działa w tle, czy na pierwszym planie. Jestem zmęczony szukaniem rozwiązania. Każda pomoc jest mile widziana.

Aby wyświetlić komunikat banerowy, gdy aplikacja jest na pierwszym planie, użyj następującej metody.

iOS 10, Swift 3/4 :

// This method will be called when app received push notifications in foreground
func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) 
{
    completionHandler([.alert, .badge, .sound])
}

iOS 10, Swift 2.3 :

@available(iOS 10.0, *)
func userNotificationCenter(center: UNUserNotificationCenter, willPresentNotification notification: UNNotification, withCompletionHandler completionHandler: (UNNotificationPresentationOptions) -> Void)
{
    //Handle the notification
    completionHandler(
       [UNNotificationPresentationOptions.Alert,
        UNNotificationPresentationOptions.Sound,
        UNNotificationPresentationOptions.Badge])
}

Musisz również zarejestrować delegata aplikacji jako delegata centrum powiadomień:

import UserNotifications

// snip!

class AppDelegate : UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate

// snip!

   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

      // set the delegate in didFinishLaunchingWithOptions
      UNUserNotificationCenter.current().delegate = self
      ...
   }

Poniższy kod będzie dla Ciebie odpowiedni:

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo  {
    application.applicationIconBadgeNumber = 0;             
    //self.textView.text = [userInfo description];
    // We can determine whether an application is launched as a result of the user tapping the action
    // button or whether the notification was delivered to the already-running application by examining
    // the application state.

    if (application.applicationState == UIApplicationStateActive) {                
        // Nothing to do if applicationState is Inactive, the iOS already displayed an alert view.                
        UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Did receive a Remote Notification" message:[NSString stringWithFormat:@"Your App name received this notification while it was running:\n%@",[[userInfo objectForKey:@"aps"] objectForKey:@"alert"]]delegate:self cancelButtonTitle:@"OK" otherButtonTitles:nil];
        [alertView show];          
    }    
}

Dla każdego, kto może być zainteresowany, stworzyłem niestandardowy widok, który wygląda jak systemowy baner push na górze, ale dodaje przycisk zamykania (mały niebieski X) i opcję stuknięcia wiadomości dla niestandardowej akcji. Obsługuje także przypadek wysłania więcej niż jednego powiadomienia, zanim użytkownik zdąży odczytać / odrzucić stare (bez ograniczenia liczby osób, które mogą się gromadzić ...)

Link do GitHub: AGPushNote

Użycie jest w zasadzie on-line:

[AGPushNoteView showWithNotificationMessage:@"John Doe sent you a message!"];

I tak to wygląda na iOS7 (iOS6 ma wygląd iOS6 ...)

Cel C

Ponieważ iOS 10potrzebujemy zintegrować willPresentNotificationmetodę wyświetlania baneru powiadomień foreground.

Jeśli aplikacja jest w trybie pierwszego planu (aktywna)

- (void)userNotificationCenter:(UNUserNotificationCenter* )center willPresentNotification:(UNNotification* )notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler {
    NSLog( @“Here handle push notification in foreground" ); 
    //For notification Banner - when app in foreground

    completionHandler(UNNotificationPresentationOptionAlert);

    // Print Notification info
    NSLog(@"Userinfo %@",notification.request.content.userInfo);
}

Jeśli aplikacja działa na pierwszym planie, iOS nie wyświetla baneru powiadomienia / alertu. To z założenia. Ale możemy to osiągnąć, wykorzystując UILocalNotificationw następujący sposób

• Sprawdź, czy aplikacja jest w stanie aktywnym po otrzymaniu zdalnego
  powiadomienia. Jeśli w stanie aktywnym, uruchom powiadomienie UILocalNotification.

  if (application.applicationState == UIApplicationStateActive ) {
  
      UILocalNotification *localNotification = [[UILocalNotification alloc] init];
      localNotification.userInfo = userInfo;
      localNotification.soundName = UILocalNotificationDefaultSoundName;
      localNotification.alertBody = message;
      localNotification.fireDate = [NSDate date];
      [[UIApplication sharedApplication] scheduleLocalNotification:localNotification];
  }

SZYBKI:

if application.applicationState == .active {
    var localNotification = UILocalNotification()
    localNotification.userInfo = userInfo
    localNotification.soundName = UILocalNotificationDefaultSoundName
    localNotification.alertBody = message
    localNotification.fireDate = Date()
    UIApplication.shared.scheduleLocalNotification(localNotification)
}

Jeśli aplikacja działa na pierwszym planie, iOS nie wyświetla baneru powiadomienia / alertu. To z założenia. Musisz napisać kod, aby poradzić sobie z sytuacją, w której aplikacja otrzymuje powiadomienie, gdy jest na pierwszym planie. Powinieneś pokazać powiadomienie w najbardziej odpowiedni sposób (na przykład dodając numer identyfikacyjny do UITabBarikony, symulując baner Centrum powiadomień itp.).

Xcode 10 Swift 4.2

Aby wyświetlić powiadomienie push, gdy aplikacja jest na pierwszym planie -

Krok 1: Dodaj delegowanego UNUserNotificationCenterDelegate w klasie AppDelegate.

class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate {

Krok 2: Ustaw delegata UNUserNotificationCenter

let notificationCenter = UNUserNotificationCenter.current()
notificationCenter.delegate = self

Krok 3: ten krok pozwoli Twojej aplikacji wyświetlać powiadomienie push, nawet jeśli aplikacja jest na pierwszym planie

func userNotificationCenter(_ center: UNUserNotificationCenter,
                                willPresent notification: UNNotification,
                                withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        completionHandler([.alert, .sound])

    }

Krok 4: Ten krok jest opcjonalny . Sprawdź, czy Twoja aplikacja jest na pierwszym planie, a jeśli jest na pierwszym planie, pokaż Lokalną powiadomienie push.

func application(_ application: UIApplication,didReceiveRemoteNotification userInfo: [AnyHashable: Any],fetchCompletionHandler completionHandler:@escaping (UIBackgroundFetchResult) -> Void) {

        let state : UIApplicationState = application.applicationState
        if (state == .inactive || state == .background) {
            // go to screen relevant to Notification content
            print("background")
        } else {
            // App is in UIApplicationStateActive (running in foreground)
            print("foreground")
            showLocalNotification()
        }
    }

Funkcja lokalnego powiadomienia -

fileprivate func showLocalNotification() {

        //creating the notification content
        let content = UNMutableNotificationContent()

        //adding title, subtitle, body and badge
        content.title = "App Update"
        //content.subtitle = "local notification"
        content.body = "New version of app update is available."
        //content.badge = 1
        content.sound = UNNotificationSound.default()

        //getting the notification trigger
        //it will be called after 5 seconds
        let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 1, repeats: false)

        //getting the notification request
        let request = UNNotificationRequest(identifier: "SimplifiedIOSNotification", content: content, trigger: trigger)

        //adding the notification to notification center
        notificationCenter.add(request, withCompletionHandler: nil)
    }

Zgodnie z dokumentacją firmy Apple Tak, możesz wyświetlać powiadomienia, gdy aplikacja jest uruchomiona

Możesz utworzyć własne powiadomienie, które naśladuje alert banerowy.

Jednym ze sposobów jest utworzenie niestandardowego uiviewu, który wygląda jak baner i może animować i reagować na dotyk. Mając to na uwadze, możesz tworzyć jeszcze lepsze banery o jeszcze większej funkcjonalności.

Możesz też poszukać interfejsu API, który zrobi to za Ciebie, i dodaj je jako pliki podfile do swojego projektu.

Oto kilka, których użyłem:

https://github.com/terryworona/TWMessageBarManager

https://github.com/toursprung/TSMessages

Oto kod do otrzymywania powiadomień push, gdy aplikacja jest w stanie aktywnym (na pierwszym planie lub otwarta). Dokumentacja UNUserNotificationCenter

@available(iOS 10.0, *)
func userNotificationCenter(center: UNUserNotificationCenter, willPresentNotification notification: UNNotification, withCompletionHandler completionHandler: (UNNotificationPresentationOptions) -> Void)
{
     completionHandler([UNNotificationPresentationOptions.Alert,UNNotificationPresentationOptions.Sound,UNNotificationPresentationOptions.Badge])
}

Aby uzyskać dostęp do informacji o użytkowniku powiadomienia, użyj kodu: notification.request.content.userInfo

Dodanie linii uzupełniającej metody obsługi do metody delegowania rozwiązało dla mnie ten sam problem:

//Called when a notification is delivered to a foreground app.
@available(iOS 10.0, *)
func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {

completionHandler([.alert, .badge, .sound])
} 

Dla szybkiego 5 parsowania słownika PushNotification

    func application(_ application: UIApplication, didReceiveRemoteNotification data: [AnyHashable : Any]) {
            if application.applicationState == .active {
                if let aps1 = data["aps"] as? NSDictionary {
                    if let dict = aps1["alert"] as? NSDictionary {
                        if let strTitle = dict["title"] as? String , let strBody = dict["body"] as? String {
                            if let topVC = UIApplication.getTopViewController() {
                                //Apply your own logic as per requirement
                                print("strTitle ::\(strTitle) , strBody :: \(strBody)")
                            }
                        }
                    }
                }
            }
        }

Aby pobrać widok z góryController, na którym pokazujemy topBanner

extension UIApplication {

    class func getTopViewController(base: UIViewController? = UIApplication.shared.keyWindow?.rootViewController) -> UIViewController? {

        if let nav = base as? UINavigationController {
            return getTopViewController(base: nav.visibleViewController)

        } else if let tab = base as? UITabBarController, let selected = tab.selectedViewController {
            return getTopViewController(base: selected)

        } else if let presented = base?.presentedViewController {
            return getTopViewController(base: presented)
        }
        return base
    }
}

W swojej aplikacji deleguj użyj poniższego kodu

import UIKit
import UserNotifications
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate {
 var currentToken: String?
 var window: UIWindow?
 func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        application.registerForRemoteNotifications()
        let center = UNUserNotificationCenter.current()
        center.requestAuthorization(options: [.alert, .sound, .badge]) { (granted, error) in

            // Enable or disable features based on authorization.
            if granted == true
            {
                print("Allow")
                UIApplication.shared.registerForRemoteNotifications()
            }
            else
            {
                print("Don't Allow")
            }
        }
        UNUserNotificationCenter.current().delegate = self

        return true
    }
func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data){
        let tokenParts = deviceToken.map { data -> String in
            return String(format: "%02.2hhx", data)
        }
        let token = tokenParts.joined()
        currentToken = token  //get device token to delegate variable

    }
 public class var shared: AppDelegate {
        return UIApplication.shared.delegate as! AppDelegate
    }
 func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
         completionHandler([.alert, .badge, .sound])
    }
}

Jak wspomniano powyżej, należy użyć UserNotification.frameworkdo osiągnięcia tego. Ale dla moich celów i tak muszę to pokazać w aplikacji i chciałem mieć iOS 11styl, więc stworzyłem widok małego pomocnika, być może przydałby się komuś.

Widok powiadomień push GitHub iOS 11 .

Najlepszym sposobem na to jest dodanie UNUserNotificationCenterDelegatew AppDelegateza pomocąextension AppDelegate: UNUserNotificationCenterDelegate tego rozszerzenia informuje aplikację, aby móc otrzymać powiadomienie, gdy w użyciu

I zaimplementuj tę metodę

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        completionHandler(.alert)
    }

Ta metoda zostanie wywołana na uczestniku tylko, jeśli aplikacja jest na pierwszym planie .

Ostateczne wdrożenie:

extension AppDelegate: UNUserNotificationCenterDelegate {
    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        completionHandler(.alert)
    }
}

Aby zadzwonić, musisz ustawić delegata w AppDelegate w didFinishLaunchingWithOptionsdodać tę linię

UNUserNotificationCenter.current().delegate = self

Możesz modyfikować

completionHandler(.alert) 

z

completionHandler([.alert, .badge, .sound]))

Dla Swift 5

1) Potwierdź delegata do AppDelegate za pomocą UNUserNotificationCenterDelegate

2) UNUserNotificationCenter.current().delegate = selfwdidFinishLaunch

3) Zastosuj poniższą metodę w AppDelegate.

func userNotificationCenter(_ center: UNUserNotificationCenter,
                                willPresent notification: UNNotification,
                                withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
     print("Push notification received in foreground.")
     completionHandler([.alert, .sound, .badge])
}

Otóż ​​to!

Jak powiedział @Danial Martine, iOS nie wyświetla baneru powiadomienia / alertu. To z założenia. Ale jeśli naprawdę trzeba to zrobić, istnieje jeden sposób. Ja również to osiągnąłem.

1. Pobierz pracę parsowania ramki z Parse FrameWork

2. import #import <Parse/Parse.h>

3. Dodaj następujący kod do metody didReceiveRemoteNotification

 - (void)application:(UIApplication *)application
didReceiveRemoteNotification:(NSDictionary *)userInfo
{
    [PFPush handlePush:userInfo];
}

PFPush zajmie się obsługą zdalnego powiadomienia. Jeśli aplikacja jest na pierwszym planie, wyświetla alert, w przeciwnym razie wyświetla powiadomienie u góry.

Jeśli aplikacja znajduje się na pierwszym planie, oznacza to, że obecnie używasz tej samej aplikacji. Nie ma więc potrzeby, aby ogólnie wyświetlać powiadomienie.

Ale nadal, jeśli chcesz pokazać powiadomienie w takim przypadku, musisz utworzyć niestandardowy widok alertu lub widok niestandardowy, np. Toast lub coś innego, aby pokazać użytkownikowi, że masz powiadomienie.

Możesz również wyświetlić znaczek na górze, jeśli masz taką funkcję w swojej aplikacji.