Detect if application: didReceiveRemoteNotification: fetchCompletionHandler: was called by tapping on a notification in Notification Center

Question

application: didReceiveRemoteNotification: fetchCompletionHandler:

is different from

application: didReceiveRemoteNotification:

How? from the docs:

Unlike the application:didReceiveRemoteNotification: method, which is called only when your app is running, the system calls this method regardless of the state of your app. If your app is suspended or not running, the system wakes up or launches your app and puts it into the background running state before calling the method. If the user opens your app from the system-displayed alert, the system calls this method again so that you know which notification the user selected.

My struggle is: I want to know if the method was called by the user tapping an a system-displayed alert from the Notification Center or from a silent push notification that wakes up the device. Currently, as far as I can see, there is no obvious way to differentiate.

- (BOOL)application: didFinishLaunchingWithOptions:

Tracking the launchOptions in the above method is not a solution because it's only called if the app is suspended/not running in background. If it's running in the background it doesn't get called.

Wheelwork

Answer 1

The Apple docs are a bit confusing

application: didReceiveRemoteNotification: fetchCompletionHandler:  

is used if your application supports the remote-notification background mode (ie you're doing BackgroundFetch.)

application: didReceiveRemoteNotification:  

is called when the OS receives a RemoteNotification and the app is running (in the background/suspended or in the foreground.)
You can check the UIApplicationState to see if the app was brought to foreground by the user (tapping on notification) or was already running when notification comes in.

- (void) application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {
      UIApplicationState state = [application applicationState];
        // user tapped notification while app was in background
    if (state == UIApplicationStateInactive || state == UIApplicationStateBackground) {
         // go to screen relevant to Notification content
    } else {
         // App is in UIApplicationStateActive (running in foreground)
         // perhaps show an UIAlertView
    }
}

Nevadanevai

I don't care about application: didReceiveRemoteNotification: but about application: didReceiveRemoteNotification: fetchCompletionHandler: – Wheelwork

So you're doing background fetching? I guess I am confused as to where lies the confusion. The Apple docs state (if your app support remote-notification background mode) >the system calls this method regardless of the state of your app. The docs also state >If the user opens your app from the system-displayed alert, the system calls this method again so that you know which notification the user selected. I would assume that tracking the UIApplicationState would still be applicable... – Nevadanevai

@hasan83 - what will happen if I include NSString * jsCallBack = [NSString stringWithFormat:@"testfromdelegate()"]; [self.viewController.webView stringByEvaluatingJavaScriptFromString:jsCallBack]; inside if (state == UIApplicationStateInactive || state == UIApplicationStateBackground) { // go to screen relevant to Notification content } In both cases, I am expecting the JSCallback will be executed. Is that true? Please let me know. – Corporeity

which/what both cases? – Xylograph

@hasan83 - both cases UIApplicationStateInactive and UIApplicationStateBackground? – Corporeity

that's theoretically true. but, if notification launched the app from the InActive state (closed). that means that you don't have ur ref. to self.viewController initialised in your app delegate yet. got it?or shall I explain more? – Xylograph

hmm, I am not really sure. it depend on how you initialise your view controller and where. – Xylograph

Ah! I see the point!! Even if I am invoking the app from background, my JS callback is not working :-( I am trying to achieve this in my cordova app. I have my question posted here - #30702115, if you have some time? – Corporeity

I am on the chat, as suggested by SO - could you look at my SO question when u have some time? continue this discussion in chat. – Corporeity

Swift version of this approach: let state = application.applicationState let wasInBackground = (state == .Inactive || state == .Background) – Withe

application: didReceiveRemoteNotification: is only called when the app is on foreground developer.apple.com/reference/uikit/uiapplicationdelegate/… – Edelweiss

I don't know if it's an iOS 10 thing or what, but -application: didReceiveRemoteNotification: was never being fired, even when the app was running in the foreground (I did get banners in the home screen, though). I switched to application: didReceiveRemoteNotification: fetchCompletionHandler: and it works... I'm using CloudKit subscription-based notifications. – Melanochroi

for iOS 9: not iOS 10: How do you differentiate between a 'tapping on a notification' and 'just receiving'? I'm asking this for this scenario: I have a notification that upon arriving I need to 1. download something 2. only if user has tapped show a different viewController. @hasan83 – Cello

You should be able to figure that out in the UIApplicationDelegate method application(_:willFinishLaunchingWithOptions:) or by observing the UIApplicationDidFinishLaunching notification and accessing the attached userInfo dictionary – Nevadanevai

Answer 2

You could check the UIApplication's applicationState to distinguish silent calls from calls made with the application being actively used by the user:

typedef enum : NSInteger {
   UIApplicationStateActive,
   UIApplicationStateInactive,
   UIApplicationStateBackground
} UIApplicationState;

Or keep your own flag set on the delegate's applicationDidEnterBackground:.

Teepee

The important bit: Active=App was open when notification was received, Inactive=User clicked on notification, Background=App was running in background when notification was received (content-available must be true; this case is the actual background fetching). Note that the app has to be running at least in the background. If you force-close the app, didReceiveRemoteNotification is not called. – Colmar

You can no longer do this in iOS 10+ when you enable notifications to be shown while your app runs. #23168845 – Teepee

Answer 3

Application State is not reliable because if you have control center or Apple's notification center open over your app, application: didReceiveRemoteNotification: fetchCompletionHandler: will get called and the application state will be Inactive.

I'm having the same issue trying to respond to a click on the notification while the app is in the background and there doesn't seem to be a reliable way to solely identify this.

Stillmann

Answer 4

In case of swift

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

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

Fletcher

That was not the question. The problem is how to recognize this method being called by the system or by the user action of tapping the notification. – Teepee

Answer 5

In iOS 10.0+ you can use the method

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

to detect when user taps on a system-displayed alert from the NotificationCenter.

If you implement the method above

• - (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult result))completionHandler; will be called only when a notification is received
• - (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler; will be called when user taps on notification

Louque

Answer 6

When application: didReceiveRemoteNotification:fetchCompletionHandler: method is called app state is UIApplicationStateInactive if user taps on alert (in this case you would like to prepare some UI) and is UIApplicationStateBackground when app is silently woken (in this case you just load some data).

Whipping

In the case of iOS 10+ the notification can be shown while the app is open. In this case both the system and the user tap will call application:didReceiveRemoteNotification:fetchCompletionHandler: and both will have application.applicationState == .active which is a problem. – Teepee

Answer 7

I'm not sure if I understand your question.

Do you want to differentiate between a silent push notification background fetch and a noisy push notification? You can simply check whether the push notification dictionary contains the "content-available" key: [[userInfo objectForKey:@"aps"] objectForKey:@"content-available"] If it does, then it should be a silent push. If not, it was a normal push.

Do you want to know if that background fetch method is called when the application receives a notification and it is in suspended/not running? If so, you can do the following:

• Download and import LumberJacks into your app. Look through the directions and learn how to set it up such that you can save logs to the disk.

• Put this in any method you want to see whether/when that method is invoked:

  • DDLogDebug(@"%@ - %@",NSStringFromSelector(_cmd),NSStringFromClass([self class]));

  This will print the class and the method to the log file.

• Examine the log file after sending yourself a push notification to your background-fetch enabled app, and see if any of the methods get called by looking at your log file.

If you have set up your app correctly for background fetch, the method application: didReceiveRemoteNotification: fetchCompletionHandler: will be called even when the app is backgrounded/not running if you receive a push notification (silent push or not).

Scriber

Answer 8

For Swift: In application(_:didFinishLaunchingWithOptions:) parse the application options. If they exist, you know the app was launched from them tapping.

  if let remoteNotif = launchOptions?[UIApplicationLaunchOptionsKey.remoteNotification] as? [String: Any] {
        print("Remote notfi is \(remoteNotif)")
        if let notification = remoteNotif["aps"] as? [AnyHashable : Any] {
        /// - parse notification
      }
  }

Otherwise, you can handle the tap in, and you know that the app is open/background/inactiveapplication(_:didReceiveRemoteNotification:fetchCompletionHandler:)

Widthwise