Wykryj, czy aplikacja została uruchomiona / otwarta z powiadomienia push

Czy można dowiedzieć się, czy aplikacja została uruchomiona / otwarta z powiadomienia push?

Wydaje mi się, że wydarzenie inauguracyjne można złapać tutaj:

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    if (launchOptions != nil) {
         // Launched from push notification
         NSDictionary *notification = [launchOptions objectForKey:UIApplicationLaunchOptionsRemoteNotificationKey];

    }
}

Jak jednak mogę wykryć, że została otwarta z powiadomienia push, gdy aplikacja była w tle?

Zobacz ten kod:

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
{
    if ( application.applicationState == UIApplicationStateInactive || application.applicationState == UIApplicationStateBackground  )
    {
         //opened from a push notification when the app was on background
    }
}

taki sam jak

-(void)application:(UIApplication *)application didReceiveLocalNotification (UILocalNotification *)notification

późno, ale może przydatne

Gdy aplikacja nie działa

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions

jest nazywany ..

gdzie musisz sprawdzić powiadomienia push

NSDictionary *notification = [launchOptions objectForKey:UIApplicationLaunchOptionsRemoteNotificationKey];
if (notification) {
    NSLog(@"app recieved notification from remote%@",notification);
    [self application:application didReceiveRemoteNotification:notification];
} else {
    NSLog(@"app did not recieve notification");
}

Problem, który napotkaliśmy, polegał na poprawnym aktualizowaniu widoku po uruchomieniu aplikacji. Istnieją tu skomplikowane sekwencje metod cyklu życia, które są mylące.

Metody cyklu życia

Nasze testy na iOS 10 ujawniły następujące sekwencje metod cyklu życia dla różnych przypadków:

DELEGATE METHODS CALLED WHEN OPENING APP  

Opening app when system killed or user killed  
    didFinishLaunchingWithOptions  
    applicationDidBecomeActive    

Opening app when backgrounded  
    applicationWillEnterForeground  
    applicationDidBecomeActive  

DELEGATE METHODS WHEN OPENING PUSH

Opening push when system killed
    [receiving push causes didFinishLaunchingWithOptions (with options) and didReceiveRemoteNotification:background]
    applicationWillEnterForeground
    didReceiveRemoteNotification:inactive
    applicationDidBecomeActive

Opening push when user killed
    didFinishLaunchingWithOptions (with options)
    didReceiveRemoteNotification:inactive [only completionHandler version]
    applicationDidBecomeActive

Opening push when backgrounded
    [receiving push causes didReceiveRemoteNotification:background]
    applicationWillEnterForeground
    didReceiveRemoteNotification:inactive
    applicationDidBecomeActive

Problem

Ok, więc teraz musimy:

1. Sprawdź, czy użytkownik otwiera aplikację po naciśnięciu
2. Zaktualizuj widok na podstawie stanu wypychania
3. Wyczyść stan, aby kolejne otwarcia nie powodowały powrotu użytkownika do tej samej pozycji.

Problem polega na tym, że aktualizacja widoku musi nastąpić, gdy aplikacja faktycznie staje się aktywna, co jest tą samą metodą cyklu życia we wszystkich przypadkach.

Szkic naszego rozwiązania

Oto główne elementy naszego rozwiązania:

1. Przechowuj notificationUserInfozmienną wystąpienia w AppDelegate.
2. Ustaw notificationUserInfo = nilw obu applicationWillEnterForegroundi didFinishLaunchingWithOptions.
3. Ustaw notificationUserInfo = userInfowdidReceiveRemoteNotification:inactive
4. Od applicationDidBecomeActivezawsze wywołuj niestandardową metodę openViewFromNotificationi podaj self.notificationUserInfo. Jeśli self.notificationUserInfojest nil, wróć wcześniej, w przeciwnym razie otwórz widok na podstawie stanu powiadomienia znalezionego w self.notificationUserInfo.

Wyjaśnienie

Podczas otwierania z wypychania didFinishLaunchingWithOptionslub applicationWillEnterForegroundjest zawsze wywoływana bezpośrednio przed didReceiveRemoteNotification:inactive, więc najpierw resetujemy notificationUserInfo w tych metodach, aby nie było przestarzałego stanu. Następnie, jeśli didReceiveRemoteNotification:inactivezostanie wywołany, wiemy, że otwieramy z push, więc ustawiamy, self.notificationUserInfoktóry jest następnie odbierany, applicationDidBecomeActiveaby przekierować użytkownika do właściwego widoku.

Jest jeszcze jeden przypadek, w którym użytkownik ma otwartą aplikację w przełączniku aplikacji (tj. Dwukrotne dotknięcie przycisku strony głównej, gdy aplikacja jest na pierwszym planie), a następnie otrzymuje powiadomienie push. Tylko w tym przypadku didReceiveRemoteNotification:inactivejest wywoływana i ani WillEnterForeground, ani didFinishLaunching nie są wywoływane, więc do obsługi tego przypadku potrzebny jest specjalny stan.

Mam nadzieję że to pomoże.

To bardzo wysłużony post ... ale wciąż brakuje w nim rzeczywistego rozwiązania problemu (jak wskazano w różnych komentarzach).

Pierwotne pytanie dotyczyło wykrycia, kiedy aplikacja została uruchomiona / otwarta z powiadomienia push, np. Użytkownik stuka w powiadomienie. Żadna z odpowiedzi tak naprawdę nie dotyczy tego przypadku.

Powód można zobaczyć w przebiegu połączenia, gdy nadejdzie powiadomienie, application:didReceiveRemoteNotification...

zostaje wywołany, gdy powiadomienie zostanie odebrane ORAZ ponownie, gdy powiadomienie zostanie dotknięte przez użytkownika. Z tego powodu nie można tego stwierdzić, patrząc po prostu, UIApplicationStateczy użytkownik ją stuknął.

Ponadto nie musisz już zajmować się sytuacją `` zimnego startu '' aplikacji, application:didFinishLaunchingWithOptions...jak application:didReceiveRemoteNotification...to się nazywa ponownie po uruchomieniu w iOS 9+ (może również 8).

Jak więc możesz stwierdzić, czy użytkownik kliknął, rozpoczął łańcuch zdarzeń? Moim rozwiązaniem jest zaznaczenie czasu, w którym aplikacja zaczyna wychodzić z tła lub zimnego startu, a następnie sprawdzenie tego czasu application:didReceiveRemoteNotification.... Jeśli jest krótszy niż 0,1 s, możesz być całkiem pewien, że dotknięcie spowodowało uruchomienie.

Swift 2.x

class AppDelegate: UIResponder, UIApplicationDelegate {

  var wakeTime : NSDate = NSDate()        // when did our application wake up most recently?

  func applicationWillEnterForeground(application: UIApplication) {    
    // time stamp the entering of foreground so we can tell how we got here
    wakeTime = NSDate()
  }

  func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject : AnyObject], fetchCompletionHandler completionHandler: (UIBackgroundFetchResult) -> Void) {
    // ensure the userInfo dictionary has the data you expect
    if let type = userInfo["type"] as? String where type == "status" {
      // IF the wakeTime is less than 1/10 of a second, then we got here by tapping a notification
      if application.applicationState != UIApplicationState.Background && NSDate().timeIntervalSinceDate(wakeTime) < 0.1 {
        // User Tap on notification Started the App
      }
      else {
        // DO stuff here if you ONLY want it to happen when the push arrives
      }
      completionHandler(.NewData)
    }
    else {
      completionHandler(.NoData)
    }
  }
}

Szybki 3

class AppDelegate: UIResponder, UIApplicationDelegate {

    var wakeTime : Date = Date()        // when did our application wake up most recently?

    func applicationWillEnterForeground(_ application: UIApplication) {
      // time stamp the entering of foreground so we can tell how we got here
      wakeTime = Date()
    }

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

      // ensure the userInfo dictionary has the data you expect
      if let type = userInfo["type"] as? String, type == "status" {
        // IF the wakeTime is less than 1/10 of a second, then we got here by tapping a notification
        if application.applicationState != UIApplicationState.background && Date().timeIntervalSince(wakeTime) < 0.1 {
          // User Tap on notification Started the App
        }
        else {
          // DO stuff here if you ONLY want it to happen when the push arrives
        }
        completionHandler(.newData)
      }
      else {
        completionHandler(.noData)
      }
    }
}

Przetestowałem to w obu przypadkach (aplikacja w tle, aplikacja nie działa) na iOS 9+ i działa jak urok. 0,1 s jest również dość konserwatywne, rzeczywista wartość to ~ 0,002 s, więc 0,01 również jest w porządku.

Gdy aplikacja zostanie zamknięta, a użytkownik kliknie powiadomienie push

public func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
   if launchOptions?[UIApplicationLaunchOptionsKey.remoteNotification] != nil {
      print("from push")
    }
}

Gdy aplikacja działa w tle, a użytkownik dotyka powiadomienia push

Jeśli użytkownik otworzy aplikację z poziomu alertu wyświetlanego przez system, system może ponownie wywołać tę metodę, gdy aplikacja ma zamiar wejść na pierwszy plan , aby można było zaktualizować interfejs użytkownika i wyświetlić informacje dotyczące powiadomienia.

public func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject : AnyObject], fetchCompletionHandler completionHandler: (UIBackgroundFetchResult) -> Void) {
  if application.applicationState == .inactive {
    print("from push")
  }
}

W zależności od Twojej aplikacji może również wysłać Ci cichy push z content-availablewnętrzem aps, więc pamiętaj również o tym :) Zobacz https://stackoverflow.com/a/33778990/1418457

Swift 2.0 dla stanu `` nie działa '' (powiadomienie lokalne i zdalne)

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {


// Handle notification
if (launchOptions != nil) {

    // For local Notification
    if let localNotificationInfo = launchOptions?[UIApplicationLaunchOptionsLocalNotificationKey] as? UILocalNotification {

        if let something = localNotificationInfo.userInfo!["yourKey"] as? String {
            self.window!.rootViewController = UINavigationController(rootViewController: YourController(yourMember: something))
        }


    } else

    // For remote Notification
    if let remoteNotification = launchOptions?[UIApplicationLaunchOptionsRemoteNotificationKey] as! [NSObject : AnyObject]? {

        if let something = remoteNotification["yourKey"] as? String {
            self.window!.rootViewController = UINavigationController(rootViewController: YourController(yourMember: something))
        }
    }

}


return true
}

W application:didReceiveRemoteNotification:sprawdzić, czy otrzymaliśmy powiadomienie, gdy aplikacja jest na pierwszym planie lub w tle.

Jeśli został odebrany w tle, uruchom aplikację z poziomu powiadomienia.

-(void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {
    if ([UIApplication sharedApplication].applicationState == UIApplicationStateActive) {
        NSLog(@"Notification received by running app");
    } else {
        NSLog(@"App opened from Notification");
    }
}

Dla szybkiego:

func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject : AnyObject]) {
    PFPush.handlePush(userInfo)

    if application.applicationState == UIApplicationState.Inactive || application.applicationState == UIApplicationState.Background {
        //opened from a push notification when the app was in the background

    }

}

Tak, możesz wykryć tą metodą w appDelegate :

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
{
      /* your Code*/
}

W przypadku powiadomienia lokalnego:

- (void)application:(UIApplication *)application
didReceiveLocalNotification:(UILocalNotification *)notification
{
         /* your Code*/
}

jeśli ktoś chce uzyskać szybką odpowiedź 3

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any]) {
    switch application.applicationState {
    case .active:
        //app is currently active, can update badges count here
        break
    case .inactive:
        //app is transitioning from background to foreground (user taps notification), do what you need when user taps here
        break
    case .background:
        //app is in background, if content-available key of your notification is set to 1, poll to your backend to retrieve data and update your interface here
        break
    default:
        break
    }
}

Publikowanie tego dla użytkowników platformy Xamarin.

Kluczem do wykrycia, czy aplikacja została uruchomiona za pośrednictwem powiadomienia wypychanego, jest AppDelegate.FinishedLaunching(UIApplication app, NSDictionary options)metoda i słownik opcji, który jest przekazywany.

Słownik opcje będą mieć ten klucz w nim, czy jest to lokalny powiadomienie: UIApplication.LaunchOptionsLocalNotificationKey.

Jeśli jest to zdalne powiadomienie, będzie UIApplication.LaunchOptionsRemoteNotificationKey.

Gdy klucz jest LaunchOptionsLocalNotificationKey, obiekt jest typu UILocalNotification. Następnie możesz spojrzeć na powiadomienie i określić, które to jest konkretne powiadomienie.

Porada od specjalistów: UILocalNotificationnie zawiera identyfikatora, tak samo jak UNNotificationRequest. Umieść klucz słownika w UserInfo zawierającym requestId, aby podczas testowania UILocalNotificationbył dostępny określony requestId, na którym można oprzeć pewną logikę.

Zauważyłem, że nawet na urządzeniach iOS 10+, które podczas tworzenia powiadomień o lokalizacji za pomocą UNUserNotificationCenter's AddNotificationRequest& UNMutableNotificationContent, że gdy aplikacja nie działa (zabiłem ją) i jest uruchamiana przez dotknięcie powiadomienia w centrum powiadomień, że słownik nadal zawiera UILocalNotificaitonprzedmiot.

Oznacza to, że mój kod sprawdzający uruchamianie na podstawie powiadomień będzie działał na urządzeniach z systemem iOS 8 i iOS 10+

public override bool FinishedLaunching (UIApplication app, NSDictionary options)
{
    _logger.InfoFormat("FinishedLaunching");

    if(options != null)
    {
        if (options.ContainsKey(UIApplication.LaunchOptionsLocalNotificationKey))
        {
            //was started by tapping a local notification when app wasn't previously running.
            //works if using UNUserNotificationCenter.Current.AddNotificationRequest OR UIApplication.SharedApplication.PresentLocalNotificationNow);

            var localNotification = options[UIApplication.LaunchOptionsLocalNotificationKey] as UILocalNotification;

            //I would recommended a key such as this :
            var requestId = localNotification.UserInfo["RequestId"].ToString();
        }               
    }
    return true;
}

Prosto z dokumentacji dla

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

Jeśli aplikacja działa i odbiera zdalne powiadomienie, wywołuje tę metodę w celu przetworzenia powiadomienia.

Twoja implementacja tej metody powinna korzystać z powiadomienia, aby podjąć odpowiednie działania.

I trochę później

Jeśli aplikacja nie działa w momencie nadejścia powiadomienia wypychanego, metoda uruchamia aplikację i udostępnia odpowiednie informacje w słowniku opcji uruchamiania.

Aplikacja nie wywołuje tej metody w celu obsługi tego powiadomienia wypychanego.

Zamiast tego Twoja implementacja

application:willFinishLaunchingWithOptions:

lub

application:didFinishLaunchingWithOptions:

musi pobrać dane ładunku powiadomienia wypychanego i odpowiednio zareagować.

Zacznę od wykresu stanu, który utworzyłem na własny użytek, aby go dokładniej zwizualizować i wziąć pod uwagę wszystkie inne stany: https://docs.google.com/spreadsheets/d/e/2PACX-1vSdKOgo_F1TZwGJBAED4C_7cml0bEATqeL3P9UKpBwASlT6ZkU3iubLg31g ? gid = 0 & single = true

Korzystając z tego wykresu, możemy zobaczyć, co jest faktycznie wymagane, aby opracować solidny system obsługi powiadomień, który działa w prawie wszystkich możliwych przypadkach użycia.

Kompletne rozwiązanie ↓

• Przechowuj ładunek powiadomienia w didReceiveRemoteNotification
• Wyczyść zapisane powiadomienie w applicationWillEnterForeground i didFinishLaunchingWithOptions
• Aby poradzić sobie z przypadkami, w których Centrum sterowania / Centrum powiadomień zostało wyciągnięte, możesz użyć flagi willResignActiveCalled i początkowo ustawić ją na false , Ustaw to na true w metodzie applicationWillResignActive ,
• W metodzie didReceiveRemoteNotification zapisuj powiadomienia (userInfo) tylko wtedy, gdy willResignActiveCalled ma wartość false.
• Zresetuj willResignActiveCalled na false w metodzie applicationDidEnterBackground i applicationDidBecomeActive .

Uwaga: Podobna odpowiedź jest sugerowana w komentarzach do odpowiedzi Erica, jednak arkusz stanu pomaga w znalezieniu wszystkich możliwych scenariuszy, tak jak w mojej aplikacji.

Proszę znaleźć pełny kod poniżej i komentarz poniżej, jeśli jakikolwiek konkretny przypadek nie jest obsługiwany:

AppDelegate

class AppDelegate: UIResponder, UIApplicationDelegate {
  private var willResignActiveCalled = false

  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    NotificationUtils.shared.notification = nil
    return true
  }
  func applicationWillResignActive(_ application: UIApplication) {
    willResignActiveCalled = true
  }
  func applicationDidEnterBackground(_ application: UIApplication) {
    willResignActiveCalled = false
  }
  func applicationWillEnterForeground(_ application: UIApplication) {
    NotificationUtils.shared.notification = nil
  }
  func applicationDidBecomeActive(_ application: UIApplication) {
    willResignActiveCalled = false
    NotificationUtils.shared.performActionOnNotification()
  }
  func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    if !willResignActiveCalled { // Check if app is in inactive by app switcher, control center, or notification center
      NotificationUtils.shared.handleNotification(userInfo: userInfo)
    }
  }
}

NotificationUtils : Tutaj możesz napisać cały kod, aby przejść do różnych części aplikacji, obsługiwać bazy danych (CoreData / Realm) i wykonać wszystkie inne czynności, które należy wykonać po otrzymaniu powiadomienia.

   class NotificationUtils {
  static let shared = NotificationUtils()
  private init() {}

  var notification : [AnyHashable: Any]?

  func handleNotification(userInfo : [AnyHashable: Any]){
    if UIApplication.shared.applicationState == UIApplicationState.active {
      self.notification = userInfo //Save Payload
      //Show inApp Alert/Banner/Action etc
      // perform immediate action on notification
    }
    else if UIApplication.shared.applicationState == UIApplicationState.inactive{
      self.notification = userInfo
    }
    else if UIApplication.shared.applicationState == UIApplicationState.background{
      //Process notification in background,
      // Update badges, save some data received from notification payload in Databases (CoreData/Realm)
    }
  }

  func performActionOnNotification(){
    // Do all the stuffs like navigating to ViewControllers, updating Badges etc
    defer {
      notification = nil
    }
  }
}

func application(_ application: UIApplication, didReceiveRemoteNotification data: [AnyHashable : Any]) {
    print("Push notification received: \(data)")

    if let info = data["aps"] as? Dictionary<String, AnyObject> {
        let alertMsg = info["alert"] as! String
        print(alertMsg)
        switch application.applicationState {
        case .active:
            print("do stuff in case App is active")
        case .background:
            print("do stuff in case App is in background")
           // navigateToChatDetailViewControler(pushdata: data)
        case .inactive:
            print("do stuff in case App is inactive")
            // navigateToChatDetailViewControler(pushdata: data)
        }
    }
}

Jest tylko jeden niezawodny sposób i działa tylko na iOS 10+ :

Za pomocą metody UNUserNotificationCenterimplementacji UNUserNotificationCenterDelegate:

- (void) userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler {

    //Here you can get your original push if you need to
    NSDictionary* pusDict = response.notification.request.content.userInfo;

    if ([response.actionIdentifier isEqualToString: UNNotificationDefaultActionIdentifier]) {
        //User tapped the notification
    } else if ([response.actionIdentifier isEqualToString: UNNotificationDismissActionIdentifier]) {
        //User dismissed the notification 
    } else if ([response.actionIdentifier isEqualToString: MYCustomActionId]) {
        //User chose my custom defined action
    }
    ...
}

Możesz użyć:

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

do obsługi zdalnych powiadomień push.

Sprawdź tutaj dokumentację

Jeszcze tego nie próbowałem, ale może mógłbyś wysłać sobie powiadomienie? http://nshipster.com/nsnotification-and-nsnotificationcenter/

     // shanegao's code in Swift 2.0
     func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject : AnyObject])
    {
            if ( application.applicationState == UIApplicationState.Inactive || application.applicationState == UIApplicationState.Background ){
                    print("opened from a push notification when the app was on background")
            }else{
                    print("opened from a push notification when the app was on foreground")
            }
    }

Problem z tym pytaniem polega na tym, że „otwieranie” aplikacji nie jest dobrze zdefiniowane. Aplikacja jest uruchamiana na zimno ze stanu niedziałającego lub reaktywowana ze stanu nieaktywnego (np. W wyniku przełączenia z powrotem z innej aplikacji). Oto moje rozwiązanie, aby rozróżnić wszystkie te możliwe stany:

typedef NS_ENUM(NSInteger, MXAppState) {
    MXAppStateActive = 0,
    MXAppStateReactivated = 1,
    MXAppStateLaunched = 2
};

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // ... your custom launch stuff
    [[MXDefaults instance] setDateOfLastLaunch:[NSDate date]];
    // ... more custom launch stuff
}

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
    // Through a lot of trial and error (by showing alerts), I can confirm that on iOS 10
    // this method is only called when the app has been launched from a push notification
    // or when the app is already in the Active state.  When you receive a push
    // and then launch the app from the icon or apps view, this method is _not_ called.
    // So with 99% confidence, it means this method is called in one of the 3 mutually exclusive cases
    //    1) we are active in the foreground, no action was taken by the user
    //    2) we were 'launched' from an inactive state (so we may already be in the main section) by a tap
    //       on a push notification
    //    3) we were truly launched from a not running state by a tap on a push notification
    // Beware that cases (2) and (3) may both show UIApplicationStateInactive and cant be easily distinguished.
    // We check the last launch date to distinguish (2) and (3).

    MXAppState appState = [self mxAppStateFromApplicationState:[application applicationState]];
    //... your app's logic
}

- (MXAppState)mxAppStateFromApplicationState:(UIApplicationState)state {
    if (state == UIApplicationStateActive) {
        return MXAppStateActive;
    } else {
        NSDate* lastLaunchDate = [[MXDefaults instance] dateOfLastLaunch];
        if (lastLaunchDate && [[NSDate date] timeIntervalSinceDate:lastLaunchDate] < 0.5f) {
            return MXAppStateLaunched;
        } else {
            return MXAppStateReactivated;
        }
    }
    return MXAppStateActive;
}

I MXDefaultsjest tylko małym opakowaniem NSUserDefaults.

Dla swift

 func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject : AnyObject]){

    ++notificationNumber
    application.applicationIconBadgeNumber =  notificationNumber;

    if let aps = userInfo["aps"] as? NSDictionary {

        var message = aps["alert"]
        println("my messages : \(message)")

    }
}

Xcode 10 Swift 4.2.0 Łatka

func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject : AnyObject]) {

    let state : UIApplicationState = application.applicationState
    if (state == .Inactive || state == .Background) {
        // coming from background
    } else {
        // App is running in foreground
    }
}

W przypadku iOS 10+ możesz użyć tej metody, aby dowiedzieć się, kiedy kliknięto powiadomienie, niezależnie od stanu aplikacji.

func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {

    //Notification clicked
    completionHandler()
}

Odpowiedź M.Othmana jest poprawna dla aplikacji, które nie zawierają delegata sceny Dla aplikacji delegata sceny To działało dla mnie na iOS 13

Oto kod, który należy zapisać w will connect scene

if connectionOptions.notificationResponse == nil { 
//Not opened from push notification
} else {
  //Opened from push notification
}

Kod delegata aplikacji do obsługi wcześniejszych wersji didFinishLaunchingWithOptions

let notification = launchOptions?[UIApplication.LaunchOptionsKey.remoteNotification]
        if (notification != nil) {

            //Launched from push notification
        } else {

            //Launch from other source
        }

Dla szybkich użytkowników:

Jeśli chcesz uruchomić inną stronę podczas otwierania z wypychania lub czegoś podobnego, musisz to sprawdzić w następujący sposób didFinishLaunchingWithOptions:

let directVc: directVC! = directVC(nibName:"directVC", bundle: nil)
let pushVc: pushVC! = pushVC(nibName:"pushVC", bundle: nil)

if let remoteNotification = launchOptions?[UIApplicationLaunchOptionsRemoteNotificationKey] as? NSDictionary {
     self.navigationController = UINavigationController(rootViewController: pushVc!)
} else {
     self.navigationController = UINavigationController(rootViewController: directVc!)
}
self.window!.rootViewController = self.navigationController

W SWIFT:

Uruchamiam powiadomienia push (z pobieraniem w tle). Kiedy moja aplikacja działa w tle i otrzymuję powiadomienie push, stwierdziłem, że didReceiveRemoteNotification w appDelegate zostanie wywołane dwukrotnie; raz, gdy otrzymano powiadomienie, a drugi, gdy użytkownik kliknie alert powiadomienia.

Aby wykryć, czy kliknięto alert powiadomienia, po prostu sprawdź, czy applicationState surowa wartość == 1 wewnątrz didReceiveRemoteNotification w appDelegate.

func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject: AnyObject]) {
    // If not from alert click applicationState(1)
    if (application.applicationState.rawValue != 1) {
        // Run your code here
    }
}

Mam nadzieję, że to pomoże.

Gdy aplikacja jest w tle , możesz użyć shanegao

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
{
    if ( application.applicationState == UIApplicationStateInactive || application.applicationState == UIApplicationStateBackground  )
    {
         //opened from a push notification when the app was on background
    }
}

Ale jeśli chcesz uruchomić aplikację i gdy aplikacja jest zamknięta i chcesz debugować aplikację, możesz przejść do Edytuj schemat iw lewym menu wybierz Uruchom, a następnie podczas uruchamiania wybierz Czekaj na uruchomienie pliku wykonywalnego, a następnie uruchom aplikację, gdy kliknij powiadomienie push

Edytuj schemat> Uruchom> Poczekaj na uruchomienie pliku wykonywalnego