it-swarm.com.de

Ermitteln Sie, ob die App über eine Push-Benachrichtigung gestartet oder geöffnet wurde

Kann man wissen, ob die App über eine Push-Benachrichtigung gestartet oder geöffnet wurde?

Ich denke, das Startereignis kann hier gefangen werden:

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

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

    }
}

Wie kann ich jedoch feststellen, dass es von einer Push-Benachrichtigung aus geöffnet wurde, während sich die App im Hintergrund befand?

145
joao

Siehe diesen Code:

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

gleich wie 

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

spät, aber vielleicht nützlich

Wenn die App nicht läuft

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

wird genannt ..

hier müssen Sie nach Push-Benachrichtigungen suchen

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");
}
124
M.Othman

Das Problem bestand darin, die Ansicht nach dem Start der App korrekt zu aktualisieren. Es gibt hier komplizierte Sequenzen von Lebenszyklusmethoden, die verwirrend werden.

Lebenszyklusmethoden

Unsere Tests für iOS 10 zeigten die folgenden Abfolgen von Lebenszyklusmethoden für die verschiedenen Fälle:

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

Das Problem

Ok, jetzt müssen wir: 

  1. Stellen Sie fest, ob der Benutzer die App über einen Push öffnet
  2. Aktualisieren Sie die Ansicht basierend auf dem Push-Status
  3. Löschen Sie den Status, damit nachfolgende Öffnen den Benutzer nicht an dieselbe Position zurückbringen.

Das schwierige an der Sache ist, dass die Aktualisierung der Ansicht erfolgen muss, wenn die Anwendung tatsächlich aktiv wird. Dies ist in allen Fällen dieselbe Lebenszyklusmethode.

Skizze unserer Lösung

Hier sind die Hauptkomponenten unserer Lösung:

  1. Speichern Sie eine notificationUserInfo-Instanzvariable im AppDelegate.
  2. Setzen Sie notificationUserInfo = nil in applicationWillEnterForeground und didFinishLaunchingWithOptions.
  3. Setze notificationUserInfo = userInfo in didReceiveRemoteNotification:inactive
  4. Rufen Sie in applicationDidBecomeActive immer eine benutzerdefinierte Methode openViewFromNotification auf und übergeben Sie self.notificationUserInfo. Wenn self.notificationUserInfo null ist, kehren Sie früh zurück, andernfalls öffnen Sie die Ansicht basierend auf dem Benachrichtigungsstatus in self.notificationUserInfo.

Erklärung

Beim Öffnen von Push didFinishLaunchingWithOptions oder applicationWillEnterForeground wird immer unmittelbar vor didReceiveRemoteNotification:inactive aufgerufen. Deshalb setzen wir notificationUserInfo zunächst in diesen Methoden zurück, sodass kein veralteter Zustand auftritt. Wenn dann didReceiveRemoteNotification:inactive aufgerufen wird, wissen wir, dass wir uns von einem Push öffnen, so dass wir self.notificationUserInfo setzen, der dann von applicationDidBecomeActive abgerufen wird, um den Benutzer in die rechte Ansicht weiterzuleiten.

Es gibt einen letzten Fall, in dem der Benutzer die App im App-Switcher geöffnet hat (d. H. Durch doppeltes Antippen der Home-Taste, während sich die App im Vordergrund befindet) und dann eine Push-Benachrichtigung erhält. In diesem Fall wird nur didReceiveRemoteNotification:inactive aufgerufen, und es werden weder WillEnterForeground noch didFinishLaunching aufgerufen. Sie benötigen also einen speziellen Status, um diesen Fall zu bearbeiten.

Hoffe das hilft.

25
Eric Conner

Dies ist ein abgenutzter Beitrag ... aber es fehlt noch eine tatsächliche Lösung des Problems (wie in den verschiedenen Kommentaren darauf hingewiesen).

Die ursprüngliche Frage betrifft das Erkennen, wann die App gestartet wurde /aus einer Push-Benachrichtigung geöffnet, z. tippt ein Benutzer auf die Benachrichtigung. Keine der Antworten umfasst diesen Fall.

Der Grund ist im Anrufverlauf zu sehen, wenn eine Benachrichtigung eingeht, application:didReceiveRemoteNotification...

wird aufgerufen, wenn die Benachrichtigung empfangen wird UND erneut, wenn der Benutzer die Benachrichtigung antippt. Aus diesem Grund können Sie nicht einfach anhand von UIApplicationState feststellen, ob der Benutzer darauf tippt.

Darüber hinaus müssen Sie die Situation eines "Kaltstarts" der App in application:didFinishLaunchingWithOptions... nicht mehr behandeln, da application:didReceiveRemoteNotification... nach dem Start in iOS 9+ (möglicherweise auch 8) erneut aufgerufen wird.

Wie können Sie also feststellen, ob der Benutzer die Ereigniskette gestartet hat? Meine Lösung ist, den Zeitpunkt zu markieren, zu dem die App aus dem Hintergrund oder Kaltstart kommt, und dann diese Zeit in application:didReceiveRemoteNotification... zu überprüfen. Wenn es weniger als 0,1s ist, können Sie ziemlich sicher sein, dass der Abgriff den Start ausgelöst hat.

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

Ich habe dies für beide Fälle (App im Hintergrund, App läuft nicht) auf iOS 9+ getestet und funktioniert wie ein Zauber. 0.1s ist auch ziemlich konservativ, der tatsächliche Wert ist ~ 0.002s, also ist 0.01 auch gut. 

23
MobileVet

Swift 2.0 für Status "Nicht ausgeführt" (lokale und Remote-Benachrichtigung)

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

}

18

Prüfen Sie in application:didReceiveRemoteNotification:, ob Sie die Benachrichtigung erhalten haben, wenn sich Ihre App im Vordergrund oder Hintergrund befindet.

Wenn es im Hintergrund empfangen wurde, starten Sie die App über die Benachrichtigung.

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

Wenn die App beendet wird und der Benutzer auf Push-Benachrichtigung tippt

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

Wenn sich die App im Hintergrund befindet und der Benutzer auf Push-Benachrichtigung tippt

Wenn der Benutzer Ihre App über die vom System angezeigte Warnung öffnet, ruft das System diese Methode möglicherweise erneut auf. Wenn Ihre App kurz vor dem Vordergrund erscheint, können Sie Ihre Benutzeroberfläche aktualisieren und Informationen anzeigen, die sich auf die Benachrichtigung beziehen.

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

Abhängig von Ihrer App kann es Ihnen auch einen stillen Push mit content-available in aps senden. Beachten Sie dies ebenfalls :) Siehe https://stackoverflow.com/a/33778990/1418457

15
onmyway133

Für 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

    }

}
12
LondonGuy

Ja, Sie können diese Methode in appDelegate erkennen: 

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

Für lokale Benachrichtigung:

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

wenn jemand die Antwort in Swift 3 möchte

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

Ich beginne mit einem Zustandsdiagramm, das ich für meine Zwecke erstellt habe, um es genauer darzustellen und um alle anderen Zustände zu berücksichtigen: https://docs.google.com/spreadsheets/d/e/2PACX- 1vSdKOgo_F1TZwGJBAED4C_7cml0bEATqeL3P9UKpBwASlT6ZkU3iLdZnOZoevkMzOeng7gs31IFhD-L/pubhtml? Gid = 0 & single = true

Anhand dieses Diagramms können wir sehen, was tatsächlich erforderlich ist, um ein robustes Benachrichtigungsverarbeitungssystem zu entwickeln, das in nahezu allen möglichen Anwendungsfällen funktioniert.

Komplettlösung ↓

  • Speichern Sie notification payload in didReceiveRemoteNotification
  • Löschen gespeicherte Benachrichtigung in applicationWillEnterForeground und didFinishLaunchingWithOptions
  • Um Fälle zu lösen, in denen das Kontrollzentrum/Benachrichtigungszentrum aktiviert wurde, können Sie ein Flag willResignActiveCalled verwenden und es zunächst auf false setzen to true in applicationWillResignActive method,
  • Speichern Sie in der Methode didReceiveRemoteNotification Benachrichtigungen (userInfo) nur, wenn willResignActiveCalled false ist.
  • Zurücksetzen willResignActiveCalled to false in applicationDidEnterBackground und applicationDidBecomeActive Methode.

Hinweis: Eine ähnliche Antwort wird in Kommentaren zu Erics Antwort vorgeschlagen. Das Statusblatt hilft jedoch dabei, alle möglichen Szenarien zu finden, wie ich es in meiner App getan habe.

Unten finden Sie den vollständigen Code und unten einen Kommentar, falls ein bestimmter Fall nicht behandelt wird:

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 : Hier können Sie Ihren gesamten Code schreiben, um zu verschiedenen Teilen der Anwendung zu navigieren, Datenbanken (CoreData/Realm) zu verwalten und alle anderen Aufgaben zu erledigen, die zu diesem Zeitpunkt ausgeführt werden müssen eine Benachrichtigung wird empfangen.

   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
    }
  }
}
2
chetan anand

Posting für Xamarin-Benutzer.

Der Schlüssel zum Erkennen, ob die App über eine Push-Benachrichtigung gestartet wurde, ist die AppDelegate.FinishedLaunching(UIApplication app, NSDictionary options)-Methode und das übergebene Optionswörterbuch.

Das Optionswörterbuch enthält diesen Schlüssel, wenn es sich um eine lokale Benachrichtigung handelt: UIApplication.LaunchOptionsLocalNotificationKey.

Wenn es sich um eine Remote-Benachrichtigung handelt, handelt es sich um UIApplication.LaunchOptionsRemoteNotificationKey.

Wenn der Schlüssel LaunchOptionsLocalNotificationKey ist, hat das Objekt den Typ UILocalNotification. Sie können dann die Benachrichtigung anzeigen und feststellen, um welche bestimmte Benachrichtigung es sich handelt.

Pro-Tipp: UILocalNotification enthält keinen Bezeichner, genauso wie UNNotificationRequest. Geben Sie einen Wörterbuchschlüssel in die UserInfo ein, der eine requestId enthält, so dass Sie beim Testen der UILocalNotification eine bestimmte requestId zur Verfügung haben, auf der die Logik basiert.

Ich habe festgestellt, dass selbst auf Geräten mit iOS 10 und mehr, wenn beim Erstellen von Standortbenachrichtigungen die UNUserNotificationCenter & AddNotificationRequest von UNMutableNotificationContent verwendet wird, dass, wenn die App nicht ausgeführt wird (ich sie abgebrochen habe) und durch Tippen auf die Benachrichtigung im Benachrichtigungscenter das Wörterbuch immer noch gestartet wird enthält das UILocalNotificaiton-Objekt.

Dies bedeutet, dass mein Code, der nach einem Benachrichtigungs-basierten Start sucht, auf iOS8- und iOS 10+-Geräten funktioniert

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

Es gibt nur einen zuverlässigen Weg und funktioniert nur für iOS 10+ :

UNUserNotificationCenter implementieren UNUserNotificationCenterDelegate-Methode:

- (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
    }
    ...
}
2
Luten

Für 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)")

    }
}
0
idris yıldız
     // 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")
            }
    }
0
Sean Dev

Sie können verwenden:

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

für die Remote-Push-Benachrichtigungen.

Überprüfen Sie hier die Dokumentation

0
sunkehappy

Wenn die App im Hintergrund als shanegao ist, können Sie sie verwenden

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

Wenn Sie jedoch die Anwendung starten möchten und wenn die Anwendung geschlossen ist und Sie Ihre Anwendung debuggen möchten, können Sie zu Edit Scheme gehen und im linken Menü Run wählen und dann beim Start Wait for Executable auswählen gestartet werden und dann die Anwendung gestartet wird, wenn Sie auf Push-Benachrichtigung klicken

Edit Scheme> Run> Warten auf den Start der ausführbaren Datei

0
salmancs43

Xcode 10 Swift 4.2

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

Das Problem bei dieser Frage ist, dass das "Öffnen" der App nicht klar definiert ist. Eine App wird entweder aus einem nicht laufenden Status kalt gestartet oder aus einem inaktiven Status reaktiviert (z. B. durch Zurückschalten von einer anderen App zu ihr). Hier ist meine Lösung, um all diese möglichen Zustände zu unterscheiden:

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

Und MXDefaults ist nur ein kleiner Wrapper für NSUserDefaults.

0
skensell
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)
        }
    }
}
0
hardik bar

Ich habe es noch nicht probiert, aber vielleicht können Sie sich selbst eine Benachrichtigung senden? http://nshipster.com/nsnotification-and-nsnotificationcenter/

0
Berendschot

Direkt aus der Dokumentation für 

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

Wenn die App ausgeführt wird und eine Remote-Benachrichtigung empfängt, ruft die App diese Methode auf, um die Benachrichtigung zu verarbeiten. 

Ihre Implementierung dieser Methode sollte die Benachrichtigung verwenden, um geeignete Maßnahmen zu ergreifen.

Und ein bisschen später

Wenn die App nicht ausgeführt wird, wenn eine Push-Benachrichtigung eingeht, startet die Methode die App und stellt die entsprechenden Informationen im Wörterbuch der Startoptionen bereit. 

Die App ruft diese Methode nicht zur Verarbeitung dieser Push-Benachrichtigung auf. 

Stattdessen Ihre Implementierung des

application:willFinishLaunchingWithOptions:

oder

application:didFinishLaunchingWithOptions:

die Methode muss die Push-Benachrichtigungsnutzdaten abrufen und entsprechend reagieren.

0
Pfitz