As you know, ProcessOne is about realtime messaging. Our core component is XMPP ejabberd scalable and ubiquitous server. We recently acquired Boxcar to use a familiar and popular brand for our large scale push notification service for mobile as well.
From this perspective, Google’s huge update on its Cloud Messaging service is the biggest announcement from this year Google I/O, as it mixes our two core strengths. We strongly believe this is a big deal for mobile developers and we will explain why.
What is Google Cloud Messaging (GCM) ?
In case you never heard about it, here is a quick overview.
Google Cloud Messaging have been announced last year as a replacement of Google Cloud to Device Messaging. This is a service that allows mobile developer to notify mobile devices (but also Chrome browser) about important changes on the server-side component of the application. It makes it possible for the device to stay up to date, without the need to use polling. Polling is about checking periodically for updates on your server and is bad for several reasons:
- it consumes lot of battery, periodically waking up the mobile device network stack.
- it consumes a lot of useless resources on the server as most of this resource lead to a “no update” reply.
- it introduces latency as the request for new data can happen long after the data availability (unless you put a very low polling interval, which is even worse for the mobile battery). You can get your news alert hours after every one already knows about it, which defeat the purpose of the alert in the first place.
Push notifications avoid all those drawbacks, saving battery life, providing lower latency, reducing server load. As a permanently connected session to Google servers, it get the important notification messages as soon as they happen, in a battery efficient way.
Being a service that runs at device level, it can be optimized across applications running on the same device and perform further battery saving benefits.
So, this is a really critical feature to implement in application relying on data coming from the network (which actually covers a lot of applications).
GCM offers nice outstanding features like:
- Support two use cases:
- “send to sync”: short notification to tell client to get update from developer server.
- “send data”: larger notification containing the data payload, avoiding an extra client to developer server roundtrip.
- Time to live can be used to destroy message without notification if device was not online before its expiration. Pending messages can also be replaced with the collapse feature.
- Delay when idle can be use for less urgent notifications. Device will get it when becoming active again.
- Multicast messages to send the same notification to up to 1000 devices.
What does GCM update brings to developers ?
The new update is a brand new service deployment bringing a large set of new features for developers.
In short, it brings:
- Persistent connections are supported between developer backend and Google, allowing sending a larger number of notifications faster.
- Upstream messaging: This allows the device to send back notifications to the developer server, through Google platform.
- Notifications synchronization between devices. Basically, this allows a developer to remove a notification from a device when it has been read / processed on another device.
GCM Cloud Connection Service (CCS): Persistent connections using XMPP
Google choose to use XMPP to allow developers to keep a persistent connection. It works as follow:
- You open an XMPP client connection to Google XMPP GCM server (Port 5235 on gcm.googleapis.com).
- You can then keep the secure connection open for as long as you wish.
- You can then send your usual GCM JSON payload in XMPP message packets.
- This is streaming so you receive possible errors asynchronously and you can match it to original push thanks to XMPP message id.
This alone brings you a huge performance increase, allowing your server to send up to 4000 messages per second on the persistent connection. Knowing you are allowed up to 10 connections, you can possibly send many notifications fast (up to 40k notifications per second).
A few things to note:
- You cannot use multicast messages with XMPP persistant connection (at least yet).
- However, you can mix HTTP connexions and XMPP persistant connections in your use case to optimize the performance depending on the use case.
Upstream messaging allows your client to send data asynchronously to your server. Compared to HTTP posts, it offer several advantages:
- It is easy for client developer, with a simple gcm.send command. This is “fire and forget”. Client developer sends the data. Android GCM framework save it locally, with the commitment to deliver it.
- It is reliable with reliability handled transparently by GCM mobile framework on the client. There is acknowledgement mechanism on the client and between GCM and your server that ensure no message can be lost.
- Timing to send is optimized across mobile applications. This allow significant battery saving for messages that are not very time sensitive. Optimization is even performed based on the server side down stream needs. If client or server send messages first, the other direction queue is flushed at the same time.
- It supports time to live. If the message could not be send, because network is unavailable and is not relevant anymore, it is discarded.
As a developer, your server will receive the message through an XMPP connection. However, be very careful about your server efficiency: you have to be robust and read data fast as the GCM server will queue for you 100 messages before starting to overwrite them (and if you are offline for 24 hours it will discard your messages).
Multi-devices notification synchronisation
The goal of this feature is to makes your notifications state becomes up to date and consistent across a user devices, by propagating state change between the user application installations on your various devices.
This feature is designed to bring many added benefits in the way multiple devices are handled.
First, to know that your app is used by the same users, you can group your device Registration Ids under the same notification_key. Notification key is typically a hash of the username. You are allowed up to 10 devices linked to that notification_key.
Once you have done that, you can use that notification_key as a user id to send notifications to all devices of a given user. By doing so, you let GCM performs lots of optimizations under the hood. Notification will be send in priority to the active device or the last active device. Other devices will get the notification a bit later in a delay while idle type of delivery.
Once the notification has been processed and dismissed, other devices are notified and they can remove the notification as well. If they were not notified yet, notification is directly canceled from the notification queue.
As you see, update to Google Cloud Messaging is really a big update for developers, increasing the number of situation this platform is relevant.
We are already working on supporting those improvements on our push notification platform to help you all benefits of those improvements.
Stay tuned for more information on this support very soon.
Here is the video of Francesco Nerieri’s talk on GCM: