Powiadomienie push na iOS: jak wykryć, czy użytkownik kliknął powiadomienie, gdy aplikacja działa w tle?

Jest wiele wątków związanych z przepełnieniem stosów dotyczących tego tematu, ale nadal nie znalazłem dobrego rozwiązania.

Jeśli aplikacja nie jest w tle, można sprawdzić launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey]na application:didFinishLaunchingWithOptions:wezwanie, aby zobaczyć czy jest otwarty od zgłoszenia.

Jeśli aplikacja działa w tle, wszystkie posty sugerują użycie application:didReceiveRemoteNotification:i sprawdzenie stanu aplikacji. Ale jak eksperymentowałem (i jak sugeruje nazwa tego API), ta metoda jest wywoływana po odebraniu powiadomienia, zamiast dotknięcia.

Problem polega więc na tym, że jeśli aplikacja jest uruchomiona, a następnie działa w tle, i wiesz, że otrzymano powiadomienie application:didReceiveNotification( application:didFinishLaunchWithOptions:nie zostanie uruchomione w tym momencie), skąd wiesz, czy użytkownik wznowił aplikację, dotykając powiadomienia lub po prostu dotykając ikonę aplikacji? Ponieważ jeśli użytkownik dotknął powiadomienia, oczekuje się, że otworzy stronę wspomnianą w tym powiadomieniu. W przeciwnym razie nie powinno.

Mógłbym użyć handleActionWithIdentifierdo powiadomień o niestandardowych akcjach, ale jest to wyzwalane tylko po dotknięciu przycisku niestandardowej akcji, a nie po dotknięciu przez użytkownika głównej treści powiadomienia.

Dzięki.

EDYTOWAĆ:

po przeczytaniu jednej odpowiedzi poniżej pomyślałem, że mogę wyjaśnić swoje pytanie:

Jak możemy rozróżnić te 2 scenariusze:

(A) 1. aplikacja przechodzi w tło; 2. otrzymane powiadomienie; 3. użytkownik dotyka powiadomienia; 4. aplikacja przechodzi na pierwszy plan

(B) 1. aplikacja przechodzi w tło; 2. otrzymane powiadomienie; 3. użytkownik ignoruje powiadomienie i później dotyka ikony aplikacji; 4. aplikacja przechodzi na pierwszy plan

Ponieważ application:didReceiveRemoteNotification:jest wyzwalane w obu przypadkach w kroku 2.

A może powinien application:didReceiveRemoteNotification:zostać uruchomiony w kroku 3 tylko dla (A), ale w jakiś sposób skonfigurowałem nieprawidłową aplikację, więc widzę ją w kroku 2?

OK, w końcu się domyśliłem.

W ustawieniach docelowych ➝ Karta Możliwości ➝ Tryby w tle, jeśli zaznaczysz opcję „Powiadomienia zdalne”, application:didReceiveRemoteNotification:zostaną uruchomione, gdy tylko nadejdzie powiadomienie (o ile aplikacja działa w tle) i w takim przypadku nie ma sposobu, aby stwierdzić, czy użytkownik dotknie powiadomienia.

Jeśli odznaczysz to pole, application:didReceiveRemoteNotification:zostanie uruchomione dopiero po dotknięciu powiadomienia.

To trochę dziwne, że zaznaczenie tego pola zmieni sposób zachowania jednej z metod delegata aplikacji. Byłoby lepiej, gdyby to pole było zaznaczone, Apple używa dwóch różnych metod delegatów do odbierania powiadomień i stukania powiadomień. Myślę, że większość programistów zawsze chce wiedzieć, czy dotknęło powiadomienia, czy nie.

Mam nadzieję, że będzie to pomocne dla każdego, kto napotka ten problem. Apple również nie udokumentował tego jasno tutaj, więc zajęło mi trochę czasu, zanim się zorientowałem.

Szukałem tego samego co Ty i znalazłem rozwiązanie, które nie wymaga odhaczania zdalnego powiadomienia.

Aby sprawdzić, czy użytkownik kliknął, aplikacja jest w tle lub jest aktywna, wystarczy sprawdzić stan aplikacji w

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

    }

Aby uzyskać więcej informacji, sprawdź:

UIKit Framework Reference> UIApplication Class Reference> UIApplicationState

Według iOS / XCode: skąd wiedzieć, że aplikacja została uruchomiona za pomocą kliknięcia powiadomienia lub ikony aplikacji Springboard? musisz sprawdzić stan aplikacji w didReceiveLocalNotification w następujący sposób:

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

Chociaż nie ma to dla mnie pełnego sensu, wydaje się, że działa.

Jeśli ktoś chce tego w swift 3.0

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
    }

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

Ja też napotkałem ten problem - ale na iOS 11 z nowym UserNotificationsFramework.

Tutaj dla mnie jest tak:

• Nowy start: application:didFinishLaunchingWithOptions:
• Otrzymano ze stanu zakończenia: application(_:didReceiveRemoteNotification:fetchCompletionHandler:)
• Otrzymane na pierwszym planie: userNotificationCenter(_:willPresent:withCompletionHandler:)
• Otrzymane w tle: userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:

Jeśli masz zaznaczone "Tryby w tle"> "Zdalne powiadomienia" == TAK, stuknij w powiadomienie, które pojawi się za:

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

Pomogło mi. Miłej zabawy :)

W moim przypadku wyłączenie trybu tła nie miało żadnego znaczenia. Jednak gdy aplikacja została zawieszona, a użytkownik dotknął powiadomienia, mogłem obsłużyć ten przypadek w tej metodzie wywołania zwrotnego:

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

}

W przypadku iOS 10 i nowszych umieść to w AppDelegate, aby dowiedzieć się, że powiadomienie jest dotknięte (działa nawet, gdy aplikacja jest zamknięta lub otwarta)

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

Istnieją dwie funkcje dla uchwytu otrzymanego w PushNotificationManagerklasie PushNotification :

class PushNotificationManager: NSObject, MessagingDelegate, UNUserNotificationCenterDelegate{

}

Jak przetestowałem pierwszy wyzwalacz, gdy tylko nadeszło powiadomienie

@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([])

}

I drugi po dotknięciu powiadomienia:

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

Przetestowałem to również z włączonymi i wyłączonymi stanami zdalnego powiadamiania (w trybach w tle)

SWIFT 5.1

UIApplication.State u mnie nie zadziałało, ponieważ po odczytaniu odcisku palca (pojawia się modal) w mojej aplikacji, powiadomienie jest również rzucane w górnym pasku i użytkownik musi go kliknąć.

Stworzyłem

public static var isNotificationFromApp: Bool = false

in AppDelegatei ustawiam to truena początku, viewControllera potem w powiadomieniu storyboard/viewController właśnie to sprawdzam :)

Mam nadzieję, że może się przydać

Możesz skonfigurować ładunek powiadomienia wypychanego, aby wywoływał delegata aplikacji application:didReceiveRemoteNotification:fetchCompletionHandler: metodę gdy aplikacja działa w tle. Możesz tutaj ustawić flagę, aby przy następnym uruchomieniu aplikacji przez użytkownika można było wykonać operację.

Z dokumentacji firmy Apple należy skorzystać z tej metody, aby pobrać nową zawartość związaną z powiadomieniem push. Aby to zadziałało, musisz włączyć zdalne powiadamianie z trybów w tle, a ładunek powiadomienia push musi zawierać content-availableklucz z wartością ustawioną na 1. Więcej informacji można znaleźć w sekcji Używanie powiadomień push do inicjowania pobierania z dokumentu Apple tutaj .

Innym sposobem jest liczenie znaczków w ładunku powiadomień push. Dlatego następnym razem, gdy aplikacja zostanie uruchomiona, możesz sprawdzić liczbę odznak aplikacji. Jeśli jego wartość jest większa od zera, wykonaj operację i zeruj / wyczyść liczbę identyfikatorów z serwera.

Mam nadzieję, że to ci pomoże.