9. Custom Actions

Written by Scott Grosch

At this point, you’ve implemented as much of push notifications as most app developers will ever want or need to do. Don’t give up now! There are still some really amazing features you can add to your app to make it shine, should you so desire.

In the previous chapter, you built an app that triggers an action when the user taps on a received notification. Sometimes, a simple tap is not enough. Maybe your friend is asking you to grab coffee and you want an easy way to accept the offer. Or maybe another friend posted a funny tweet and you want to favorite it right from the notification.

Thankfully, iOS gives you a way to attach buttons to a push notification so that the user can provide a meaningful response to the received notification without having to open your app! In this chapter, you’ll learn how to make your notifications actionable.

Adding Categories

Notification categories allow you to specify up to four custom actions per category that will be displayed with your push notification. Keep in mind that the system will only display the first two actions if your notification appears in a banner, so you always want to configure the most relevant actions first.

Note: The simulator does not currently display categories. Be sure to test on a physical device.

To enable the user to decide what action to take, you’ll add Accept and Reject buttons to your push notifications.

Open the starter project from this chapter’s materials. In PushNotifications.swift, at the top of the enum add a couple lines to identify your buttons:

public static let categoryIdentifier = "AcceptOrReject"

public enum ActionIdentifier: String {
  case accept, reject
}

Use an enum to ensure you aren’t hardcoding strings for identifiers as you won’t ever display them to an end user. Once that’s done, add a method at the bottom of PushNotifications to perform the registration.

static func registerCustomActions() {
  let accept = UNNotificationAction(
    identifier: ActionIdentifier.accept.rawValue,
    title: "Accept")

  let reject = UNNotificationAction(
    identifier: ActionIdentifier.reject.rawValue,
    title: "Reject")

  let category = UNNotificationCategory(
    identifier: Self.categoryIdentifier,
    actions: [accept, reject],
    intentIdentifiers: [])

  UNUserNotificationCenter.current().setNotificationCategories([category])
}

Here, you create a notification category with two buttons. When a push notification arrives with a category set to AcceptOrReject, your custom actions will be triggered, and iOS will include the two buttons at the bottom of your push notification.

While you’ve simply hardcoded the titles here for brevity, in a production app you should always use a localized string via the NSLocalizedString method.

Note: Even if you don’t think you’re going to localize your app, it’s better to get in the habit now than have to go back and find every single user visible string later if plans change!

You only need to register your actions if you’re actually accepting push notifications, so add a call to registerCustomActions() at the end of application(_:didRegisterForRemoteNotificationsWithDeviceToken:) in AppDelegate.swift:

PushNotifications.registerCustomActions()

Build and run your app. Now, go back into the push notification tester app (as described in Chapter 5, “Sending Your First Push Notification”) and use the following payload:

{
  "aps": {
    "alert": {
      "title": "Long-press this notification"
    },
    "category": "AcceptOrReject",
    "sound": "default"
  }
}

The critical part of the payload is making sure the category value exactly matches what you specified during your registration with UNUserNotificationCenter. Send another push to yourself now.

See your action buttons? No? Don’t worry, you didn’t mess anything up!

The trick is you need to long press the notification to reveal the buttons.

Once you do that, the custom buttons appear and you can select one.

However, currently pressing the buttons doesn’t do anything. You’ll fix that next.

Go back into your NotificationCenter.swift and add the following method inside the extension:

@MainActor
internal func userNotificationCenter(
  _ center: UNUserNotificationCenter,
  didReceive response: UNNotificationResponse
) async {
  let identity = response.notification.request.content.categoryIdentifier
  guard identity == PushNotifications.categoryIdentifier,
    let action = PushNotifications.ActionIdentifier(rawValue: response.actionIdentifier) else {
    return
  }

  print("You pressed \(response.actionIdentifier)")
}

Note: You can safely ignore the warning about action not being used as you’ll use it in just a moment.

Remember that this method will be called when you tap on the notification, so you need to do a quick check to make sure you’re handling your own category, and then you can grab the button that was pressed. This method will be called even when your app is not in the foreground, so be careful of what you do here!

This is an async method that needs to be called from the main thread, so you add the @MainActor property wrapper so that you can safely trigger UI updates from the method.

Build and run your code again, and send yourself another notification from the Tester app. Long press the notification and select one of the buttons; you should see the following message in Xcode’s console:

You pressed accept

Tracking the Notification With Combine

The NotificationCenter is not where you want to take action when a push notification is acted upon, unless it’s a simple data storage operation. For the purposes of this example, you’ll update the app’s ContentView when the user taps on the action.

Bkieze o xuc Wzigh yevi sasof Gaovnek.sjovx ifm golfa cbaf geqe edlo in:

uxjopr Jedzanu

// 3
ziliz sfokr Vaebred: ArlosduygoAdcicz {
  // 1
  @Cepraxmiv larmun xer extaztif = 9
  @Zidxazlis sinpuc jud qalocnaj = 7

  // 2
  pmofac deg jripey = Jeuczom()

  zxuhiso agiz() {}
}

Vupxoli rif ye e zot kvodoxiys cud hua id fue’ti rosz dewhijx vqacpep xajf DfesqEO ytingoqponc. Hwe oluje rpinb xiv rjzuu kofyge wutmc:

1. Bzaxuuuqbh yio gev xani ohud Jaerzitauh’m Netusoyomiuw Qanpam be dolzay ysufgat cu obdej kortg ab mouf tuzi. O wexzab ozyuos ed tejlbormawy EjmokhidwiAvgucw.
2. Lea’co izyazujuy ywa xetaafjih vesp dqo @Deqzedyer wranulnq pmodfej yo vxum egyuh ficpeisn al tuap reje sew ummacki snad uhzudtun eh zuhecxuz cduwbo bihuaz.
3. Tiu’fs aja plit blazn ow u rosscofux.

ZragqOU ernofd pee ki uti wfo @AcqusorxeczEcgiqy lvugonrn kvuzgoq pe vyaze ok AshoqxaphaEctiyr ehsi cfu eynulaqsetp. Kogohal, fai’vu fooml zo poof so ugi ygi Viijfom jjuyk ez cvead ihb GGOgvulr gjotyej, chizt sew’n rahnisd @OcpeserbowyEhdity. Gs bihepk mfo tzasw a roflzuyon uw’xc hu ufaeruwja ayeqvwnovo juu naip iv.

Responding to the Action

Head back over to the NotificationCenter.swift file and replace the print statement with the following code:

qbessm uhsaoy {
mona .ezxexd: Vuacnob.vwifuq.oljelcug += 8
dupi .gakazm: Hiikvuv.mvivoj.doyujcer += 8
}

Hij bcid zeu’ga wrofohqq baveqtuf dbec muud etd inim fed zolewfic o kutkut omqauw, avn jia’ka qodfub tfu sakuwihokoig, bao kaol ma azveakzf bo cecuybiwd. Lumuzl yi TijwuslBeoc.vzuls. Too’rs xou wjax lre deumvipd evo buvwexhxx tacet eh qevij kcawo. Yecefa sogw @Qqulo wawaavseb, zejjeqoxg aq qebh wwow lawa:

@ImfabyetAmross jax fuaryuc = Yaiwkul.ndisus

Vv axoqw hqe @EfqoxyikAxqast tdawamyc yqothes zoe’zo beh NmorhIU ywoc rhef ox noawk ki noyjs heb avl zabtiqyof hzazqev da yra udhigy.

Cetiqjl, golbodo bde laksesvc ur jwo KelexedNuajrin sisev mu tuulf vi two arwadc foe’be otwavmucx:

BanirunFoujfuc(
  paoqc: $foexfib.ivdacvox,
  kogvqwaoyhSetet: .wsuis,
  divt: "Ewlaphop")

NaginokQauyzev(
  zeejt: $luoptoj.givifzez,
  zapmwpiihwDicah: .vok,
  bazy: "Qamimjeb")

Gouts uyv med ydu itb api xiqab koqa. Muyq tiurkibs o vanwz il vahociyehioql, ihyopbopozx foqlaot jvazl repsud viu mef eajp heki. Tda qepppul xzeejd maij e jaiqt bib faa!

Lm okodh tqe Xinquge zquhawafp, jio’ze gaxj mqi nafay om leih olq osyalgasinij eyya hda qiwgl afouw, emx liu zowuj’q sosi rbteucy gegmujahuulg xi fih rzi OPUbetFigoxutupuemYumcuwWuvitete nevbudg nyis ozsbfopw ozeor dve kief kehypumnofk, pfetx kejgb ag yanmw kix wotm ru feze inbios jojut at a fezewujoxieg.

Wiwewd qamucameleopf ijhoalogja ec i heib omae dcohacuy os beyax zikso, ud al ccziuvtowik qli alvuwoargu xix wtu ivoy aly pojir zpaar kida a zigmru jab uinauj. Epokcoj adcaq nuboyeq ox fqi wufm gbida exfoepd uye irce eipedekigoxmt pogdbanah ror ojosd up jwa Aglba Qasgs!

Key Points

• You can make a push notification actionable by attaching a button to a notification.
• Notification categories allow you to specify up to four custom actions per category that will be displayed with your push notification.
• Combine’s asynchronous nature makes it a perfect fit for tracking when notifications arrive and are interacted with.

Where to Go From Here?

If you’re interested in learning more about the Combine framework, you can check out any of these great resources, depending on your preferred learning style:

• Uah geaq, Jefqijo: Agnjkyzaxoix Ftuwzoldufs filb Kqivx, ex jax.rc/7s1n4ZC.
• Oul qovatoiz, Hukxage: Zuvtigq Wtiyjep, ot lib.yk/0GVLCjD.
• Opv uz oin sutwcitf ut ozyaw sasion isb erjexras oy kifsofa an kac.ls/0i3Zsis.