Notificação push do iOS: como detectar se o usuário tocou na notificação quando o aplicativo está em segundo plano?

Existem muitos threads de stackoverflow relacionados a esse tópico, mas ainda não encontrei uma boa solução.

Se o aplicativo não está no fundo, eu posso verificar launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey]na application:didFinishLaunchingWithOptions:chamada para ver se ele está aberto a partir de uma notificação.

Se o aplicativo estiver em segundo plano, todas as postagens sugerem o uso application:didReceiveRemoteNotification:e a verificação do estado do aplicativo. Mas, como experimentei (e também como o nome desta API sugere), esse método é chamado quando a notificação é recebida, em vez de tocada.

Portanto, o problema é, se o aplicativo for iniciado e depois colocado em segundo plano, e você souber que uma notificação foi recebida de application:didReceiveNotification(application:didFinishLaunchWithOptions: não será acionada neste ponto), como saber se o usuário retomou o aplicativo tocando na notificação ou apenas tocando no ícone do aplicativo? Porque se o usuário tocou na notificação, a expectativa é abrir a página mencionada naquela notificação. Caso contrário, não deveria.

Eu poderia usar handleActionWithIdentifierpara notificações de ação personalizada, mas isso só é acionado quando um botão de ação personalizada é pressionado, não quando o usuário toca no corpo principal da notificação.

Obrigado.

EDITAR:

depois de ler uma das respostas abaixo, pensei que desta forma posso esclarecer minha dúvida:

Como podemos diferenciar esses 2 cenários:

(A) 1.app vai para segundo plano; 2. notificação recebida; 3. toque do usuário na notificação; 4. aplicativo entra em primeiro plano

(B) 1.app vai para segundo plano; 2. notificação recebida; 3. o usuário ignora a notificação e toca no ícone do aplicativo posteriormente; 4. aplicativo entra em primeiro plano

Uma vez que application:didReceiveRemoteNotification:é acionado em ambos os casos na etapa 2.

Ou deve application:didReceiveRemoteNotification:ser acionado na etapa 3 apenas para (A), mas de alguma forma configurei meu aplicativo de forma errada, então estou vendo na etapa 2?

OK, eu finalmente descobri.

Nas configurações de destino ➝ guia Capacidades ➝ Modos de fundo, se você marcar "Notificações remotas", application:didReceiveRemoteNotification:será acionado assim que a notificação chegar (contanto que o aplicativo esteja em segundo plano) e, nesse caso, não há como saber se o usuário tocará na notificação.

Se você desmarcar essa caixa, application:didReceiveRemoteNotification:será acionado apenas quando você tocar na notificação.

É um pouco estranho que marcar esta caixa altere o comportamento de um dos métodos de delegação do aplicativo. Seria melhor se essa caixa estiver marcada, a Apple usa dois métodos de delegação diferentes para receber notificações e tocar em notificações. Acho que a maioria dos desenvolvedores sempre quer saber se uma notificação foi tocada ou não.

Esperançosamente, isso será útil para qualquer pessoa que tenha esse problema. A Apple também não documentou claramente aqui, então demorei um pouco para descobrir.

Estou procurando a mesma coisa que você e realmente encontrei uma solução que não requer notificação remota para ser marcada.

Para verificar se o usuário tocou ou se o aplicativo está em segundo plano ou ativo, basta verificar o estado do aplicativo em

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

    }

Para mais informações, verifique:

Referência da estrutura UIKit> Referência de classe UIApplication> UIApplicationState

De acordo com iOS / XCode: como saber se o aplicativo foi lançado com um clique na notificação ou no ícone do aplicativo trampolim? você tem que verificar o estado do aplicativo em didReceiveLocalNotification assim:

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

Embora não faça totalmente sentido para mim, parece funcionar.

Se alguém quiser no 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
    }

para 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 você selecionou "Modos de fundo"> "Notificações remotas" == SIM, toque no evento de notificação chegará em:

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

Isso me ajudou. Por favor aproveite :)

Também tive esse problema - mas no iOS 11 com o novo UserNotificationsFramework.

Aqui para mim é assim:

• Novo lançamento: application:didFinishLaunchingWithOptions:
• Recebido de um estado finalizado: application(_:didReceiveRemoteNotification:fetchCompletionHandler:)
• Recebido em primeiro plano: userNotificationCenter(_:willPresent:withCompletionHandler:)
• Recebido em segundo plano: userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:

No meu caso, o modo de fundo OFF não fez nenhuma diferença. No entanto, quando o aplicativo foi suspenso e o usuário tocou na notificação, pude lidar com o caso neste método de retorno de chamada:

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

}

Para iOS 10 e superior, coloque-o em AppDelegate, para saber se a notificação foi tocada (funciona mesmo se o aplicativo estiver fechado ou aberto)

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

Existem dois Funcs para lidar com PushNotification recebido dentro da PushNotificationManagerclasse:

class PushNotificationManager: NSObject, MessagingDelegate, UNUserNotificationCenterDelegate{

}

Como testei o primeiro no gatilho assim que a notificação chegou

@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 o segundo quando tocado na notificação:

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

Eu também testei com os estados LIGADO e DESLIGADO de Notificação Remota (em Modos de Fundo)

SWIFT 5.1

UIApplication.State não funcionou para mim, porque depois de ler a impressão digital (modal é mostrado) em meu aplicativo, a notificação também é lançada na barra superior e o usuário deve clicar nela.

Eu criei

public static var isNotificationFromApp: Bool = false

em AppDelegatee eu configurei truena minha inicialização viewControllere, em seguida, na minha notificação storyboard/ viewControllereu acabei de verificar isso :)

Espero que possa ser útil

Você pode configurar a carga útil da sua notificação push para chamar o delegado do aplicativo application:didReceiveRemoteNotification:fetchCompletionHandler: método aplicativo quando o aplicativo está em segundo plano. Você pode definir algum sinalizador aqui para que, quando o usuário iniciar seu aplicativo na próxima vez, você possa executar sua operação.

A partir da documentação da apple, você deve usar esses métodos para baixar novo conteúdo associado à notificação push. Além disso, para que isso funcione, você deve habilitar a notificação remota nos modos de segundo plano e sua carga útil de notificação push deve conter a content-availablechave com seu valor definido como 1. Para obter mais informações, consulte Usando notificações push para iniciar um download seção do doc da apple aqui .

Outra maneira é fazer com que o emblema conte na carga útil da notificação push. Portanto, na próxima vez que seu aplicativo for iniciado, você poderá verificar a contagem de crachás do aplicativo. Se for maior que zero, execute sua operação e zerar / limpar a contagem do crachá do servidor também.

Espero que isso ajude você.