iOS-Push-Benachrichtigung: Wie erkennt man, ob der Benutzer auf Benachrichtigung getippt hat, wenn sich die App im Hintergrund befindet?

Es gibt viele Stackoverflow-Threads zu diesem Thema, aber ich habe immer noch keine gute Lösung gefunden.

Wenn sich die App nicht im Hintergrund befindet, kann ich einen Anruf einchecken, launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey]um application:didFinishLaunchingWithOptions:festzustellen, ob sie über eine Benachrichtigung geöffnet wurde.

Wenn sich die App im Hintergrund befindet, schlagen alle Beiträge vor, application:didReceiveRemoteNotification:den Anwendungsstatus zu verwenden und zu überprüfen. Aber wie ich experimentiert habe (und auch wie der Name dieser API andeutet), wird diese Methode aufgerufen, wenn die Benachrichtigung empfangen wird, anstatt darauf zu tippen.

Das Problem ist also, wenn die App gestartet und dann im Hintergrund ausgeführt wird und Sie wissen, dass eine Benachrichtigung von empfangen wird application:didReceiveNotification( application:didFinishLaunchWithOptions:wird zu diesem Zeitpunkt nicht ausgelöst), woher Sie wissen, ob der Benutzer die App wieder aufgenommen hat, indem Sie auf die Benachrichtigung tippen oder einfach auf tippen App-Symbol? Wenn der Benutzer auf die Benachrichtigung getippt hat, wird erwartet, dass die in dieser Benachrichtigung erwähnte Seite geöffnet wird. Sonst sollte es nicht.

Ich könnte handleActionWithIdentifierfür benutzerdefinierte Aktionsbenachrichtigungen verwenden, dies wird jedoch nur ausgelöst, wenn auf eine benutzerdefinierte Aktionsschaltfläche getippt wird, nicht, wenn der Benutzer auf den Hauptteil der Benachrichtigung tippt.

Vielen Dank.

BEARBEITEN:

Nachdem ich eine Antwort unten gelesen hatte, dachte ich, dass ich auf diese Weise meine Frage klären kann:

Wie können wir diese beiden Szenarien unterscheiden:

(A) 1.app geht in den Hintergrund; 2. Benachrichtigung erhalten; 3. Der Benutzer tippt auf die Benachrichtigung. 4. App tritt in den Vordergrund

(B) 1.app geht in den Hintergrund; 2. Benachrichtigung erhalten; 3. Der Benutzer ignoriert die Benachrichtigung und tippt später auf das App-Symbol. 4. App tritt in den Vordergrund

Da application:didReceiveRemoteNotification:wird in beiden Fällen in Schritt 2 ausgelöst.

Oder sollte application:didReceiveRemoteNotification:in Schritt 3 nur für (A) ausgelöst werden, aber ich habe meine App irgendwie falsch konfiguriert, sodass ich sie in Schritt 2 sehe?

OK, ich habe es endlich herausgefunden.

Wenn Sie in den Zieleinstellungen ➝ Registerkarte Funktionen ➝ Hintergrundmodi "Remote-Benachrichtigungen" aktivieren, application:didReceiveRemoteNotification:werden diese ausgelöst, sobald eine Benachrichtigung eintrifft (solange sich die App im Hintergrund befindet). In diesem Fall kann nicht festgestellt werden, ob Der Benutzer tippt auf die Benachrichtigung.

Wenn Sie dieses Kontrollkästchen deaktivieren, application:didReceiveRemoteNotification:wird es nur ausgelöst, wenn Sie auf die Benachrichtigung tippen.

Es ist ein wenig seltsam, dass das Aktivieren dieses Kontrollkästchens das Verhalten einer der App-Delegat-Methoden ändert. Wenn dieses Kontrollkästchen aktiviert ist, verwendet Apple zwei verschiedene Delegierungsmethoden für den Empfang von Benachrichtigungen und das Tippen auf Benachrichtigungen. Ich denke, die meisten Entwickler möchten immer wissen, ob eine Benachrichtigung aktiviert ist oder nicht.

Hoffentlich ist dies hilfreich für alle anderen, die auf dieses Problem stoßen. Apple hat es hier auch nicht klar dokumentiert, daher habe ich eine Weile gebraucht, um es herauszufinden.

Ich habe nach dem gleichen Thema gesucht wie Sie und tatsächlich eine Lösung gefunden, bei der keine Remote-Benachrichtigung angekreuzt werden muss.

Um zu überprüfen, ob der Benutzer getippt hat oder sich die App im Hintergrund befindet oder aktiv ist, müssen Sie nur den Anwendungsstatus einchecken

-(void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler{

    if(application.applicationState == UIApplicationStateActive) {

        //app is currently active, can update badges count here

    }else if(application.applicationState == UIApplicationStateBackground){

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

    }else if(application.applicationState == UIApplicationStateInactive){

        //app is transitioning from background to foreground (user taps notification), do what you need when user taps here

    }

Weitere Informationen finden Sie unter:

UIKit Framework-Referenz> UIApplication-Klassenreferenz> UIApplicationState

Laut iOS / XCode: Woher wissen Sie, dass die App mit einem Klick auf Benachrichtigung oder auf das Sprungbrett-App-Symbol gestartet wurde? Sie müssen in didReceiveLocalNotification wie folgt nach dem Anwendungsstatus suchen:

if ([UIApplication sharedApplication].applicationState == UIApplicationStateInactive)
{
    // user has tapped notification
}
else
{
    // user opened app from app icon
}

Obwohl es für mich nicht ganz sinnvoll ist, scheint es zu funktionieren.

Wenn jemand es in Swift 3.0 will

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
    }

für schnell 4

switch UIApplication.shared.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
}

Wenn Sie "Hintergrundmodi"> "Remote-Benachrichtigungen" aktiviert haben == JA, tippen Sie auf Benachrichtigungsereignis, um Folgendes zu erreichen:

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

Es hat mir geholfen. Genießen Sie bitte :)

Ich bin auch auf dieses Problem gestoßen - aber unter iOS 11 mit dem neuen UserNotificationsFramework.

Hier ist es für mich so:

• Neustart: application:didFinishLaunchingWithOptions:
• Von einem Endzustand empfangen: application(_:didReceiveRemoteNotification:fetchCompletionHandler:)
• Im Vordergrund erhalten: userNotificationCenter(_:willPresent:withCompletionHandler:)
• Im Hintergrund erhalten: userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:

In meinem Fall machte der Hintergrundmodus AUS keinen Unterschied. Wenn die App jedoch angehalten wurde und der Benutzer auf die Benachrichtigung tippte, konnte ich den Fall mit dieser Rückrufmethode behandeln:

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

}

Für iOS 10 und höher geben Sie dies in AppDelegate ein, um zu erfahren, dass die Benachrichtigung getippt ist (funktioniert sogar, wenn die App geschlossen oder geöffnet ist).

func userNotificationCenter(_ center: UNUserNotificationCenter,
                                didReceive response: UNNotificationResponse,
                                withCompletionHandler completionHandler: @escaping () -> Void) {
print("notification tapped here")
}

Es gibt zwei Funktionen für das Handle, die PushNotification innerhalb der PushNotificationManagerKlasse erhalten:

class PushNotificationManager: NSObject, MessagingDelegate, UNUserNotificationCenterDelegate{

}

Da habe ich den ersten am Auslöser getestet, sobald die Benachrichtigung eingetroffen ist

@available(iOS 10.0, *)
func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {

    completionHandler(UNNotificationPresentationOptions.alert)

    //OnReceive Notification
    let userInfo = notification.request.content.userInfo
    for key in userInfo.keys {
         Constants.setPrint("\(key): \(userInfo[key])")
    }

    completionHandler([])

}

Und die zweite, wenn Sie auf Benachrichtigung tippen:

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

    //OnTap Notification
    let userInfo = response.notification.request.content.userInfo
    for key in userInfo.keys {
        Constants.setPrint("\(key): \(userInfo[key])")
    }

    completionHandler()
}

Ich habe es auch mit EIN- und AUS-Status der Fernbenachrichtigung getestet (im Hintergrundmodus).

SWIFT 5.1

UIApplication.State hat bei mir nicht funktioniert, da nach dem Lesen des Fingerabdrucks (Modal wird angezeigt) in meiner App die Benachrichtigung auch in der oberen Leiste angezeigt wird und der Benutzer darauf klicken muss.

Ich habe erstellt

public static var isNotificationFromApp: Bool = false

in AppDelegateund ich setze es truein meinem Start viewControllerund dann in meiner Benachrichtigung storyboard/ viewControllerich überprüfe das einfach :)

Hoffe, es kann nützlich sein

Sie können die Nutzdaten Ihrer Push-Benachrichtigung so konfigurieren, dass die application:didReceiveRemoteNotification:fetchCompletionHandler:Methode des App- Delegaten aufgerufen wird , wenn sich die App im Hintergrund befindet. Sie können hier ein Flag setzen, damit der Benutzer beim nächsten Start Ihrer Anwendung Ihre Operation ausführen kann.

Aus der Apple-Dokumentation sollten Sie diese Methoden verwenden, um neue Inhalte im Zusammenhang mit Push-Benachrichtigungen herunterzuladen. Damit dies funktioniert, müssen Sie die Remote-Benachrichtigung aus dem Hintergrundmodus aktivieren und Ihre Push-Benachrichtigungsnutzdaten müssen einen content-availableSchlüssel mit dem Wert 1 enthalten. Weitere Informationen finden Sie unter Verwenden von Push-Benachrichtigungen zum Initiieren eines Downloads aus dem Apple-Dokument hier .

Eine andere Möglichkeit besteht darin, die Anzahl der Ausweise in der Nutzlast der Push-Benachrichtigung zu ermitteln. Wenn Ihre Anwendung das nächste Mal gestartet wird, können Sie die Anzahl der Anwendungsausweise überprüfen. Wenn es größer als Null ist, führen Sie Ihren Vorgang durch und löschen Sie die Ausweisanzahl auch vom Server.

Hoffe das hilft dir.