7. Expanding the Application

Written by Scott Grosch

Now that you’ve got a database up and running, you need to tell your app how to connect to it. As you saw in the previous chapter, “Server Side Pushes,” Vapor will run a local server for you at http://192.168.1.1:8080 (change with your own IP address).

This is the URL that your app will need to talk to if you successfully registered for push notifications. Of course, remember to substitute your IP address in the URL.

Setting the team and bundle identifier

If you take a look at the starter project for this chapter, you’ll see that it’s a standard app that uses push notifications, utilizing the code that you used in previous chapters. Before you can use the project, however, you’ll have to configure the target so that the certificates are created for you. To do so:

1. Select PushNotifications from the Project navigator (⌘ + 1).
2. Select the PushNotifications target.
3. Open the Signing & Capabilities tab.
4. Choose your Team.
5. Change the Bundle Identifier.

Follow steps 1–4 as shown below:

Updating the server

Token details

You’ll want to be able to pass appropriate details to your web service which describes the user’s push notification registration.

Create a new Swift file called TokenDetails.swift with the following code:

import Foundation

struct TokenDetails {
  let token: String
  var debug = false
}

Your web service expects JSON data, so add an encoder to the top of the struct:

private let encoder = JSONEncoder()

To use the JSONEncoder, your struct must conform to Encodable. Add the following extension:

extension TokenDetails: Encodable {
  private enum CodingKeys: CodingKey {
    case token, debug
  }
}

You need to explicitly specify the CodingKeys because Swift, by default, will attempt to encode each property. You don’t want to encode the encoder, though. By specifying the keys of token and debug Swift knows to only encode those two properties.

Now you can implement the method which will return the encoded data. Add the following inside TokenDetails:

func encoded() -> Data {
  return try! encoder.encode(self)
}

While fully functional, there’s one more piece to implement. When you’re debugging your app, you’ll want to have an easy way to see what is being sent to the web service. Add another extension:

extension TokenDetails: CustomStringConvertible {
  var description: String {
    return String(data: encoded(), encoding: .utf8) ?? "Invalid token"
  }
}

CustomStringConvertible lets Swift know that when you pass this struct to print that it should call your custom implementation of the description property.

The last piece left is to add an initializer to TokenDetails:

init(token: Data) {
  self.token = token.reduce("") { $0 + String(format: "%02x", $1) }
  self.encoder.outputFormatting = .prettyPrinted
}

Using the .prettyPrinted setting makes the JSON output more human friendly. As you add more items to the data that you send during registration, these “pretty” lines become a life saver when debugging. You might, for example, want to store the users’ language preferences or the version of the app they are running.

Sending the tokens

Now that you have a way to generate the details which will be sent, update the application(_:didRegisterForRemoteNotificationsWithDeviceToken:) method in AppDelegate.swift.

Replace the line where you print the device token with the following code:

guard let url = URL(string: "http://192.168.1.1:8080/api/token") else {
  fatalError("Invalid URL string")
}

You first declare the URL you’ll send your token to. Remember to update the IP address with the IP of your Mac that you discovered in Chapter 6, “Server-Side Pushes”.

Next, create an instance of TokenDetails in the function:

// 2
var details = TokenDetails(token: deviceToken)

// 3
#if DEBUG
details.debug.toggle()
print(details)
#endif

If you’re running this in debug mode, you’ll print set debug to true and also print the token.

Finally, finish the function by sending the request:

var request = URLRequest(url: url)
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpMethod = "POST"
request.httpBody = details.encoded()

URLSession.shared.dataTask(with: request).resume()

You set up an HTTP POST request with the request body you built previously.

Notice that you’re not checking the status of the request. If the registration with your website or database were to fail for any reason, you wouldn’t tell your end user this as there isn’t anything they can do about it anyway. Hopefully, the next time they run your app, you would’ve fixed the server-side issue and the registration will complete successfully.

If you try to run this now, you’ll get errors as Apple blocks the URL due to App Transport Security, or ATS. In a production app, you’d probably want to connect to secure website with the TLS protocol (i.e. https websites). Since this is only a development example, you can disable that security measurment:

1. Edit the Info.plist file.
2. Right-click in the empty whitespace and choose Add Row.
3. Set the key to be App Transport Security Settings.
4. Expand your newly created App Transport Security Settings using the chevron on the left.
5. Right-click on App Transport Security Settings and choose Add Row.
6. Set the key to be Allow Arbitrary Loads and the value to be YES.

First, make sure your server from Chapter 6, “Server-Side Pushes” is running. Then build and run your app on a device. Put the app into the background by going to your home screen or locking your phone.

At this point, if you run the sendPushes.php script that you created in Chapter 6, “Server-Side Pushes,” you should get a push notification!

Note: For this to work, you need to make sure an instance of your Vapor server is running and configured to run on your IP address, as well as make sure your database is running. You also need to set up the sendPushes.php script to use your APNs token. This is all described in Chapter 6, “Server-Side Pushes”.

Extending AppDelegate

You can probably already see how the push notification code is going to be almost exactly the same in every project you create. Do a little cleanup by moving this common code to an extension. Create a new Swift file in your Xcode project called ApnsUploads.swift and then move your notification code over.

Your ApnsUploads.swift file should look like this:

import UIKit
import UserNotifications

extension AppDelegate {
  func registerForPushNotifications(application: UIApplication) {
    let center = UNUserNotificationCenter.current()
    center.requestAuthorization(
      options: [.badge, .sound, .alert]) { granted, _ in
      guard granted else { return }

      DispatchQueue.main.async {
        application.registerForRemoteNotifications()
      }
    }
  }

  func sendPushNotificationDetails(to urlString: String, using deviceToken: Data) {
    guard let url = URL(string: urlString) else {
      fatalError("Invalid URL string")
    }

    var details = TokenDetails(token: deviceToken)

    #if DEBUG
    details.debug.toggle()
    print(details)
    #endif

    var request = URLRequest(url: url)
    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpMethod = "POST"
    request.httpBody = details.encoded()

    URLSession.shared.dataTask(with: request).resume()
  }
}

Now, you have a nice extension that you can simply copy into any app where you want to use push notifications. Once that’s done, your AppDelegate.swift file becomes nice and clean, and should look like this:

import SwiftUI

class AppDelegate: NSObject, UIApplicationDelegate {
  func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions:
      [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    registerForPushNotifications(application: application)
    return true
  }

  func application(
    _ application: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
  ) {
    sendPushNotificationDetails(
      to: "http://192.168.1.1:8080",
      using: deviceToken)
  }
}

You could, of course, leave the code in AppDelegate.swift. However, many of your apps will have other requirements for the application delegate unrelated to push notifications. By extracting that code into a file of its own you make future projects easier to configure. Simply copy the ApnsUploads.swift file into the project and add a line to the appropriate delegate methods.

Key points

• Once you have your database established, you need to tell your app how to connect to it. Vapor will allow you to run a server written with Swift.
• Take the time to add some additional lines at the end of notification registration to display the body of the JSON request in a “pretty,” easy-to-read format, which can help in the future with debugging.

Where to go from here?

And there you have it! You’ve successfully built an API that saves device tokens and an app that consumes that API. This is the basic skeleton you will build upon when using push notifications. In Chapter 8, “Handling Common Scenarios,” you will start handling common push notification scenarios, such as displaying a notification while the app is in the foreground… so keep reading!