There are different solutions on the market to send push notifications; one of these is Parse, which has a friendly control panel where anyone can easily send push notifications. We will use Parse as an example, but first, it's good to understand how this works internally and how we can build our own system to send notifications.

GCM (Google Cloud Messaging) uses push notifications, which we will send to our mobile. Google has servers called GCM connection servers that handle this process. If we want to send a push notification, we need to tell these servers first, and they will send it to our device later. We need to create a server or use a third-party server, which will communicate with the GCM servers over HTTP or XMPP as the communication can be done using both protocols.

As we said earlier, we can't control exactly when a message is received because we have no control over the GCM server. It queues the message and dispatches it when the device is online.

To create our custom solution, the first thing we need to do is enable the messaging services on our app from the Google developers' website at https://developers.google.com/mobile/add?platform=android.

After you create the app, enable GCM messaging, and you will be provided with a Sender ID and a Server API Key. The sender ID was previously known as project number.

If we want to receive GCM messages, we need to register our client, which is our mobile app, with this project. To do this, our app will use the GCM API to register and obtain a token as confirmation. When this is done, the GCM servers will know that your device is ready to receive push notifications from this particular project/sender.

We need to add the play services to use this API:

 compile "com.google.android.gms:play-services:7.5.+"

The registration is done through the Instance ID API, calling instanceID.getToken with the SenderID as a parameter:

InstanceID instanceID = InstanceID.getInstance(this);
String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId),
GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

We need to call this asynchronously and keep a Boolean variable in our app to remember whether we have been successfully registered. Our token can change with time, and we'll know when it happens with the onRefreshToken() callback. The token needs to be sent to our server:

@Override
public void onTokenRefresh() {
  //Get new token from Instance ID with the code above
  //Send new token to our Server
}

Once this is done, we need to create a GCMListener and add some permissions to the Android manifest:

<uses-permission android:name="android.permission.GET_ACCOUNTS" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />

<permission android:name="com.example.gcm.permission.C2D_MESSAGE"
  android:protectionLevel="signature" />
<uses-permission android:name="com.example.gcm.permission.C2D_MESSAGE" />

<application ...>
  <receiver
    android:name="com.google.android.gms.gcm.GcmReceiver"
    android:exported="true"
    android:permission="com.google.android.c2dm.permission.SEND" >
    <intent-filter>
      <action android:name="com.google.android.c2dm.intent.RECEIVE" />
      <category android:name="com.example.gcm" />
    </intent-filter>
  </receiver>
  <service
    android:name="com.example.MyGcmListenerService"
    android:exported="false" >
    <intent-filter>
      <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    </intent-filter>
  </service>
  <service
    android:name="com.example.MyInstanceIDListenerService"
    android:exported="false">
    <intent-filter>
      <action android:name="com.google.android.gms.iid.InstanceID"/>
    </intent-filter>
  </service>
</application>

</manifest>

GCMListener will contain the onMessageReceived method, which will be called when we receive any message.

This is all we need from the client side; for the server side, we won't go into details in this book because it totally depends on the technology and the language chosen. There are different code snippets and scripts to send the notifications for Python, Grails, Java, and so on, which are easy to find on the Web.

We don't really need a server to send a notification because we can communicate directly with GCM. All we need to do is send a POST request to https://gcm-http.googleapis.com/gcm/send. This can easily be done using any online POST-sending service, such as http://hurl.it or Postman, a Google Chrome extension used to send network requests. This is how our request needs to look:

Content-Type:application/json
Authorization:key="SERVER_API_LEY"
{
  "to" : "RECEIVER_TOKEN"
  "data" : {
    "text":"Testing GCM"
  },
}

Continuing with MasteringAndroidApp, we will implement push notifications with Parse.

For our example, we will stick to Parse. The main reason is that we don't need to worry about the server side, and we don't have to create an app in the Google developer console with this solution. Another good reason is that it has a nice built-in control panel to send this notification, and we can target different users if we have been tracking users with different parameters in advance.

With Parse, we don't need to create a GCM listener. Instead, it uses a service that is already included in the Parse library, and we just need to register a subscriber for this service. All we need to do is add the permissions and receivers to our app, and we are ready to go:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="android.permission.VIBRATE" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.GET_ACCOUNTS" />
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
<permission android:protectionLevel="signature" android:name="com.packtub.masteringandroidapp.permission.C2D_MESSAGE" />
<uses-permission android:name="com.packtpub.masteringandroidapp.permission.C2D_MESSAGE" />

Ensure that the last two permissions match your package name. The receivers need to go inside the application tag:

<service android:name="com.parse.PushService" />
<receiver android:name="com.parse.ParseBroadcastReceiver">
  <intent-filter>
    <action android:name="android.intent.action.BOOT_COMPLETED" />
    <action android:name="android.intent.action.USER_PRESENT" />
  </intent-filter>
</receiver>

<receiver android:name="com.parse.ParsePushBroadcastReceiver"
  android:exported="false">
  <intent-filter>
    <action android:name="com.parse.push.intent.RECEIVE" />
    <action android:name="com.parse.push.intent.DELETE" />
    <action android:name="com.parse.push.intent.OPEN" />
  </intent-filter>
</receiver>

<receiver android:name="com.parse.GcmBroadcastReceiver"
  android:permission="com.google.android.c2dm.permission.SEND">
  <intent-filter>
    <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
    <category android:name="com.packtpub.masteringandroidapp" />
  </intent-filter>
</receiver>

</application>

To listen for notifications, we can register a subscriber in the OnCreate method of our Application class:

ParsePush.subscribeInBackground("", new SaveCallback() {
  @Override
  public void done(com.parse.ParseException e) {
    if (e == null) {
      Log.d("com.parse.push", "successfully subscribed to the broadcast channel.");
    } else {
      Log.e("com.parse.push", "failed to subscribe for push", e);
      }
  }
});

Now, it's ready. Simply go to the Parse web, select the Push tab, and click on + Send a push. You can specify the audience, if you want to send it immediately or with a delay, and other parameters. It will keep a track of the push sent and indicate the people it was sent to.

If you see 1 in the Pushes Sent column and then take a look at the notification in your device, all is correct. The notification in your device should look as follows:

At the moment, we can see the default notification, which is created by the Parse receiver. However, we can set our own receiver and create nicer notifications with NotificationCompat. This component was introduced in the support v4 library, displaying notifications with the latest features in Android L and M as well as in previous versions until API 4.

In a few words, what we need to do is create a notification with the help of NotificationCompat.Builder and pass this notification to the system with NotificationManager.notify():

public class MyNotificationReceiver  extends BroadcastReceiver {
  
  @Override
  public void onReceive(Context context, Intent intent) {
    Notification notification = new NotificationCompat.Builder(context)
    .setContentTitle("Title")
    .setContentText("Text")
    .setSmallIcon(R.drawable.ic_launcher)
    .build();
    NotificationManagerCompat.from(context).notify(1231,notification);
  }
  
}

This will show our notification. The title, text, and icon are mandatory; if we don't add these three properties, the notification won't be shown. To start using our custom receiver, we need to specify in the manifest the register that we want to use, instead of the Parse push receiver:

receiver android:name="com.packtpub.masteringandroidapp.MyNotificationReceiver" android:exported="false">
  <intent-filter>
    <action android:name="com.parse.push.intent.RECEIVE" />
    <action android:name="com.parse.push.intent.DELETE" />
    <action android:name="com.parse.push.intent.OPEN" />
  </intent-filter>
</receiver>

We discussed how to show custom notifications with NotificationCompat. Notifications have their own design guidelines, and they are an important part of material design. It is recommended to have a look at these guidelines and keep them in mind while using this component in your app.