Push Notifications Using Atlas App Services & iOS Realm SDK
Rate this tutorial
In a serverless application, one of the important features that we must implement for the success of our application is push notifications.
The books, as they belong to a collection synchronized with Atlas Device Sync, will not only be stored persistently on our device but will also be synchronized with our user. This means that we can retrieve the list of favorites on any device where we register with our credentials. Changes made to our favorites using other devices are automatically synchronized.
The logic of this application for sending push notifications will be done through triggers. To do this, we will define two use cases:
- A book added to my favorites list has been modified: We will make use of the Firebase tokens for each device. We relate the token received to the user so that when a book is modified, only the user/s that have it in their favorites list will receive the notification.
This application will show how we can integrate push notifications with an iOS application developed in Swift. We will discuss how we have created each part with code, diagrams, and example usage.
At the end of this tutorial, you’ll find a link to a Github repository where you’ll find both the code of the iOS application as well as the code of the App Services application.
To do this, we will make use of the Firebase SDK and the
Messaging method, so that we are notified every time the token changes or a new token is generated. In our Swift code, we will use this function to insert a new FCToken for our user.
In our App Services app, we must implement the logic of the
updateFCMUserToken function that will store the token in our user document.
We have decided to save an array of tokens to be able to send a notification to each device that the same user has used to access the application.
The following is an example of a User document in the collection:
Firebase allows us to subscribe to a topic so that we can send a notification to all devices that have ever subscribed to it without the need to send the notification to specific device tokens.
In our application, once we have registered using an email and password, we can subscribe to receive notifications every time a new book is added or deleted.
When we activate this option, what happens is that we use the Firebase SDK to register in the topic books.
The logic we follow will be as below:
Upon the occurrence of either of these two operations, the linked function shall be executed and send a push notification to the “books” topic.
To configure this trigger, we’ll make use of two very important options:
- Full Document: This will allow us to receive the document created or modified in our change event.
- Document Pre-Image: For delete operations, we will receive the document that was modified or deleted before your change event.
With these options, we can determine which changes have occurred and send a message using the title of the book to inform about the change.
The configuration of the trigger in the App Services UI will be as follows:
The function linked to the trigger will determine whether the operation occurred as an
delete and send the push notification to the topic books with the title information.
When someone adds a new book, everyone who opted-in for push notifications will receive the following:
To send a notification to a specific device, the logic will be somewhat different.
For this use case, every time a book is updated, we will search if it belongs to the favourites list of any user. For those users who have such a book, we will send a notification to all registered tokens.
This will ensure that only users who have added the updated book to their favorites will receive a notification alerting them that there has been a change.
For this part, we will need a database trigger that will monitor for updates operations on the books collection.
The configuration of this trigger is much simpler, as we only need to monitor the
updates that occur in the book collection.
The configuration of the trigger in our UI will be as follows:
When such an operation occurs, we’ll check if there is any user who has added that book to their favorites list. If there is, we will create a new document in the pushNotifications collection.
This auxiliary collection is used to optimize the sending of push notifications and handle exceptions. It will even allow us to set up a monitoring system as well as retries.
Every time we send a notification, we’ll insert a document with the following:
- The changes that occurred in the original document.
- The FCM tokens of the recipient devices.
- The date when the notification was registered.
- A processed property to know if the notification has been sent.
Here’s an example of a push notification document:
To process the notifications, we’ll have a database trigger that will monitor the pushNotifications collection, and each new document will send a notification to the tokens of the client devices.
Example of a push notification to a user:
If you have found this tutorial useful, let me know so I can continue to add more information as well as step-by-step videos on how to do this.