Détecter si l'application a été lancée/ouvert à partir d'une notification push

tard, mais peut-être utile

Lors de l'application n'est pas en cours d'exécution

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

est appelé ..

où u besoin de vérifier pour la notification 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");
}

C'est un bien usé post... mais il lui manque encore une réelle solution pour le problème (comme il est indiqué dans les différents commentaires).

La question d'origine est sur la détection lors de l'application a été lancé
/ouvert à partir d'une notification push, par exemple un utilisateur appuie sur le
la notification. Aucune des réponses couvrir cette affaire.

La raison peut être vu dans le flux d'appels lorsqu'une notification arrive, application:didReceiveRemoteNotification...

qui est appelé lorsque la notification est reçue ET à nouveau lorsque la notification est tapé par l'utilisateur. De ce fait, vous ne pouvez pas dire simplement en regardant UIApplicationState si l'utilisateur taraudés il.

En outre, vous n'avez plus besoin de gérer la situation d'un "démarrage à froid" de l'application dans application:didFinishLaunchingWithOptions... comme application:didReceiveRemoteNotification... est appelée de nouveau après le lancement d'iOS 9+ (peut-être 8).

Alors, comment pouvez-vous dire si l'utilisateur d'appuyer commencé à la chaîne des événements? Ma solution est de marquer l'heure à laquelle l'application commence à sortir de l'arrière-plan ou de démarrage à froid et ensuite vérifier que l'heure dans application:didReceiveRemoteNotification.... Si elle est inférieure à 0,1 s, alors vous pouvez être assez sûr que le robinet a déclenché le démarrage.

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)
    }
  }
}

Swift 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)
      }
    }
}

J'ai testé ce pour les deux cas (application en arrière-plan, app pas en cours d'exécution) sur iOS 9+ et il fonctionne comme un charme. 0,1 s est assez conservatrice trop, la valeur réelle est d'environ 0.002 s 0.01 est très bien.

Lorsque l'application est terminée, et l'utilisateur appuie sur la notification push

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

Lorsque l'application est en arrière-plan, et l'utilisateur appuie sur le poussoir notificaion

Si l'utilisateur ouvre votre application dans le système affiche l'alerte, le système peut appeler cette méthode à nouveau lorsque votre application est sur le point d'entrer dans le premier plan de sorte que vous pouvez mettre à jour votre interface utilisateur et d'afficher les informations relatives à la notification.

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

En fonction de votre application, il peut également vous envoyer des silencieux pousser avec content-available à l'intérieur de aps, donc être conscient de ce que bien : -) Voir https://stackoverflow.com/a/33778990/1418457

Pour swift:

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 on background

    }

}

si quelqu'un veut la réponse à swift 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
    }
}

Directement à partir de la documentation pour

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

Si l'application est en cours d'exécution et reçoit une notification à distance, l'application appelle cette méthode, le processus de notification.

Votre mise en œuvre de cette méthode doit utiliser la notification de prendre les mesures qui s'imposent.

Et un peu plus tard

Si l'application n'est pas en cours d'exécution lorsqu'une notification push arrive, la méthode lance l'application et fournit les informations appropriées dans les options de lancement du dictionnaire.

De l'application ne pas appeler cette méthode pour traiter la notification push.

Au lieu de cela, votre mise en œuvre de la

application:willFinishLaunchingWithOptions:

ou

application:didFinishLaunchingWithOptions:

méthode doit obtenir la notification push de données de la charge utile et de répondre de façon appropriée.

Je vais commencer par un état graphique que j'ai créé pour mon propre usage afin de les visualiser avec plus de précision et de considérer tous les autres états:
https://docs.google.com/spreadsheets/d/e/2PACX-1vSdKOgo_F1TZwGJBAED4C_7cml0bEATqeL3P9UKpBwASlT6ZkU3iLdZnOZoevkMzOeng7gs31IFhD-L/pubhtml?gid=0&single=true

À l'aide de ce graphique, nous pouvons voir ce qui est réellement nécessaire pour développer une notification robuste système de traitement qui fonctionne dans presque tous les cas d'utilisation possibles.

Solution complète ↓

• Magasin notification charge dans didReceiveRemoteNotification
• Clair stockées notification dans applicationWillEnterForeground et didFinishLaunchingWithOptions
• Pour s'attaquer aux cas où le contrôle Center/centre de Notification tiré, vous pouvez utiliser un drapeau willResignActiveCalled et mis à faux d'abord,
  Réglez ce vrai dans applicationWillResignActive méthode,
• Dans didReceiveRemoteNotification méthode, enregistrer les notifications(userInfo) uniquement lorsque willResignActiveCalled est faux.
• Réinitialiser willResignActiveCalled de faux dans applicationDidEnterBackground et applicationDidBecomeActive méthode.

Remarque: Une Semblable réponse est suggéré dans les commentaires sur Eric réponse, toutefois, l'état fiche d'aide à la recherche de tous les scénarios possibles, comme je l'ai fait dans mon application.

Vous trouverez le code complet ci-dessous et de commentaire ci-dessous si un cas concret, n'est pas géré:

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 : C'est là que vous pouvez écrire tous vos codes pour accéder à différentes parties de l'application, gestion des Bases de données(CoreData/Domaine) et faire toutes les autres choses qui doit être fait lorsqu'une notification est reçue.

   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
    }
  }
}

Je n'ai pas encore essayé, mais peut-être vous pourriez vous envoyer une notification? http://nshipster.com/nsnotification-and-nsnotificationcenter/

Le problème avec cette question, c'est que "l'ouverture" de l'application n'est pas bien défini. Une application est soit froid lancé à partir d'un état non exécuté, ou la réactivation d'un état inactif (par exemple, de passage à partir d'une autre application). Voici ma solution pour distinguer tous ces états possibles:

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;
}

Et MXDefaults est juste un petit wrapper pour NSUserDefaults.

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)
        }
    }
}

Pour Les Clients De Swift:

Si vous souhaitez vous lancer sur une page différente de l'ouverture de pousser ou quelque chose comme ça, vous devez vérifier dans didFinishLaunchingWithOptions comme:

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

Lorsque l'application est en arrière-plan comme shanegao vous pouvez utiliser

- (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
    }
}

Mais si vous voulez lancer l'application et lorsque l'application est fermée et que vous souhaitez déboguer votre application, vous pouvez aller à Modifier le Schéma et dans le menu de gauche sélectionnez Exécuter puis de lancer sélectionnez Attendre pour le fichier exécutable à être lancé et puis vous lancement de l'application lorsque vous cliquez sur la notification push

Modifier le Schéma > Exécuter > Attendre pour le fichier exécutable à être lancé