Notifica push iOS: come rilevare se l'utente ha toccato la notifica quando l'app è in background?

Ci sono molti thread di stackoverflow su questo argomento, ma non ho ancora trovato una buona soluzione.

Se l'applicazione non è in background, posso verificare launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey]in application:didFinishLaunchingWithOptions:chiamata per vedere se è aperto da una notifica.

Se l'app è in background, tutti i post suggeriscono di utilizzare application:didReceiveRemoteNotification:e controllare lo stato dell'applicazione. Ma come ho sperimentato (e anche come suggerisce il nome di questa API), questo metodo viene chiamato quando viene ricevuta la notifica, invece di essere toccato.

Quindi il problema è che, se l'app viene avviata e poi in background e sai che una notifica viene ricevuta da application:didReceiveNotification( application:didFinishLaunchWithOptions:non si attiverà a questo punto), come fai a sapere se l'utente ha ripreso l'app da toccando la notifica o semplicemente toccando il icona dell'app? Perché se l'utente ha toccato la notifica, l'aspettativa è di aprire la pagina menzionata in quella notifica. Altrimenti non dovrebbe.

Potrei usarlo handleActionWithIdentifierper le notifiche di azioni personalizzate, ma questo viene attivato solo quando viene toccato un pulsante di azione personalizzato, non quando l'utente tocca il corpo principale della notifica.

Grazie.

MODIFICARE:

dopo aver letto una risposta di seguito, ho pensato in questo modo di poter chiarire la mia domanda:

Come possiamo differenziare questi 2 scenari:

(A) 1.app va in background; 2. notifica ricevuta; 3. l'utente tocca la notifica; 4. l'app entra in primo piano

(B) 1.app va in background; 2. notifica ricevuta; 3. l'utente ignora la notifica e tocca successivamente l'icona dell'app; 4. l'app entra in primo piano

Poiché application:didReceiveRemoteNotification:viene attivato in entrambi i casi al passaggio 2.

Oppure, dovrebbe application:didReceiveRemoteNotification:essere attivato nel passaggio 3 solo per (A), ma in qualche modo ho configurato la mia app in modo errato, quindi lo vedo al passaggio 2?

OK ho finalmente capito.

Nelle impostazioni di destinazione ➝ scheda Funzionalità ➝ Modalità in background, se selezioni "Notifiche remote", application:didReceiveRemoteNotification:verranno attivate non appena arriva la notifica (purché l'app sia in background), e in tal caso non c'è modo di dire se l'utente toccherà la notifica.

Se deselezioni quella casella, application:didReceiveRemoteNotification:verrà attivato solo quando tocchi la notifica.

È un po 'strano che la selezione di questa casella cambierà il comportamento di uno dei metodi delegati dell'app. Sarebbe più bello se quella casella fosse selezionata, Apple utilizza due diversi metodi delegati per la ricezione delle notifiche e il tocco delle notifiche. Penso che la maggior parte degli sviluppatori voglia sempre sapere se una notifica viene attivata o meno.

Si spera che questo sia utile per chiunque altro si imbatta in questo problema. Anche Apple non lo ha documentato chiaramente qui, quindi mi ci è voluto un po 'per capirlo.

Stavo cercando la tua stessa cosa e in realtà ho trovato una soluzione che non richiede la notifica remota per essere spuntata.

Per verificare se l'utente ha toccato, o l'app è in background o è attiva, devi solo controllare lo stato dell'applicazione in

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

    }

Per maggiori informazioni controlla:

Riferimento framework UIKit> Riferimento classe UIApplication> UIApplicationState

Secondo iOS / XCode: come sapere che l'app è stata avviata con un clic sulla notifica o sull'icona dell'app trampolino di lancio? devi controllare lo stato dell'applicazione in didReceiveLocalNotification in questo modo:

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

Sebbene non abbia del tutto senso per me, sembra funzionare.

Se qualcuno lo vuole in 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
    }

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

Se hai selezionato "Modalità in background"> ​​"Notifiche remote" == SÌ, tocca l'evento di notifica che arriverà tra:

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

Mi ha aiutato. Divertitevi :)

Mi sono imbattuto anche in questo problema, ma su iOS 11 con il nuovo UserNotificationsFramework.

Qui per me è così:

• Nuovo lancio: application:didFinishLaunchingWithOptions:
• Ricevuto da uno stato di terminazione: application(_:didReceiveRemoteNotification:fetchCompletionHandler:)
• Ricevuto in primo piano: userNotificationCenter(_:willPresent:withCompletionHandler:)
• Ricevuto in background: userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:

Nel mio caso, la modalità sfondo OFF non ha fatto alcuna differenza. Tuttavia, quando l'app è stata sospesa e l'utente ha toccato la notifica, ho potuto gestire il caso con questo metodo di richiamata:

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

}

Per iOS 10 e versioni successive, mettilo in AppDelegate, per sapere che la notifica è toccata (funziona anche se l'app è chiusa o aperta)

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

Ci sono due funzioni per l'handle ricevuto PushNotification all'interno della PushNotificationManagerclasse:

class PushNotificationManager: NSObject, MessagingDelegate, UNUserNotificationCenterDelegate{

}

Come ho provato il primo trigger non appena è arrivata la notifica

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

}

E il secondo quando si tocca la notifica:

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

L'ho anche testato con entrambi gli stati ON e OFF della notifica remota (in modalità in background)

SWIFT 5.1

UIApplication.State non ha funzionato per me, perché una volta che ho letto l'impronta digitale (viene mostrato modale) nella mia app, la notifica viene anche lanciata nella barra superiore e l'utente deve fare clic su di essa.

Ho creato

public static var isNotificationFromApp: Bool = false

in AppDelegatee l'ho impostato trueall'inizio viewControllere poi nella mia notifica storyboard/ viewControllerlo controllo solo :)

Spero che possa tornare utile

È possibile configurare il payload della notifica push per chiamare il application:didReceiveRemoteNotification:fetchCompletionHandler:metodo del delegato dell'app quando l'app è in background. È possibile impostare alcuni flag qui in modo che la prossima volta che l'utente avvierà l'applicazione, sia possibile eseguire l'operazione.

Dalla documentazione di Apple dovresti usare questo metodo per scaricare nuovi contenuti associati alla notifica push. Inoltre, affinché funzioni, è necessario abilitare la notifica remota dalle modalità in background e il payload della notifica push deve contenere la content-availablechiave con il valore impostato su 1. Per ulteriori informazioni, vedere la sezione Utilizzo delle notifiche push per avviare un download da Apple doc qui .

Un altro modo è avere il conteggio dei badge nel payload delle notifiche push. Quindi la prossima volta che la tua applicazione verrà avviata potrai controllare il numero di badge dell'applicazione. Se è maggiore di zero, esegui l'operazione e azzera / cancella anche il conteggio dei badge dal server.

Spero che questo ti aiuti.