Xamarin Push Notifications Using Azure Notifications Hub

The CheckDevice method ensures the device the app is running on support Google Play services, needed for notifications. CheckManifest method ensures your manifest is correctly configured, if needed and the Register method registers this application with the Project ID you get from Google developer console previously.

Now you have your Android app registered, but for being able to receive notifications you need to create a background service able to process them when they arrive to the device. To make this you will need the following two classes:

• MyBroadcastReceiver, registered as the receiver of Google Cloud Messaging notifications.
• GcmService, the actual implementation of the code needed to receive and process notifications.

First, you need to add some permissions attributes to the namespace of the classes:

[assembly: Permission(Name = "notificationsHub.Android.permission.C2D_MESSAGE")]  
[assembly: UsesPermission(Name = "notificationsHub.Android.permission.C2D_MESSAGE")]  
[assembly: UsesPermission(Name = "com.google.android.c2dm.permission.RECEIVE")]  
  
[assembly: UsesPermission(Name = "android.permission.GET_ACCOUNTS")]  
[assembly: UsesPermission(Name = "android.permission.INTERNET")]  
[assembly: UsesPermission(Name = "android.permission.WAKE_LOCK")]  
  
namespace NotificationsHub.Android  

The class MyBroadcastReceiver also needs some more attributes to be properly identified. MyBroadcastReceiver will inherit from GcmBroadcastReceiverBase<T> being T = your own GcmService class:

[BroadcastReceiver(Permission = Gcm.Client.Constants.PERMISSION_GCM_INTENTS)]  
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_MESSAGE }, Categories = new string[] { "@PACKAGE_NAME@" })]  
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_REGISTRATION_CALLBACK }, Categories = new string[] { "@PACKAGE_NAME@" })]  
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_LIBRARY_RETRY }, Categories = new string[] { "@PACKAGE_NAME@" })]  
public class MyBroadcastReceiver : GcmBroadcastReceiverBase<GcmService>  
{  
    public static string[] SENDER_IDS = new string[] { "<PROJECT ID>" };  
  
    public const string TAG = "MyBroadcastReceiver-GCM";  
}

The GcmService class needs to have the service attribute and inherit from the GcmServiceBase class. Before beginning to type in the code, you will need to add a new NuGet package to your project, called "Xamarin.NotificationHub":

[Service] //Must use the service tag  
public class GcmService : GcmServiceBase  
{  
    public static string RegistrationID { get; private set; }  
    private NotificationHub Hub { get; set; }  
  
    public GcmService() : base("<PROJECT ID>")  
    {  
        Log.Info(MyBroadcastReceiver.TAG, "GcmService() constructor");  
    }  
  
    protected override async void OnRegistered(Context context, string registrationId)  
    {  
        Log.Verbose(MyBroadcastReceiver.TAG, "GCM Registered: " + registrationId);  
        RegistrationID = registrationId;  
  
        createNotification("GcmService-GCM Registered...", "The device has been Registered, Tap to View!");  
  
        Hub = new NotificationHub("nhsampledemo", "<listen endpoint>");  
        try  
        {  
            await Hub.UnregisterAllAsync(registrationId);  
        }  
        catch (Exception ex)  
        {  
            Debug.WriteLine(ex.Message);  
            Debugger.Break();  
        }  
  
        try  
        {  
            List<string> TAGS = new List<string>()  
            {  
            };  
            var hubRegistration = await Hub.RegisterNativeAsync(registrationId, TAGS);  
        }  
        catch (Exception ex)  
        {  
            Debug.WriteLine(ex.Message);  
            Debugger.Break();  
        }  
    }  
  
    protected override void OnMessage(Context context, Intent intent)  
    {  
        Log.Info(MyBroadcastReceiver.TAG, "GCM Message Received!");  
  
        var msg = new StringBuilder();  
  
        if (intent != null && intent.Extras != null)  
        {  
            foreach (var key in intent.Extras.KeySet())  
                msg.AppendLine(key + "=" + intent.Extras.Get(key).ToString());  
        }  
  
        string messageText = intent.Extras.GetString("msg");  
        if (!string.IsNullOrEmpty(messageText))  
        {  
            createNotification("New hub message!", messageText);  
            return;  
        }  
  
        createNotification("Unknown message details", msg.ToString());  
    }  
  
    void createNotification(string title, string desc)  
    {  
        var notificationManager = GetSystemService(Context.NotificationService) as NotificationManager;  
        var uiIntent = new Intent(this, typeof(FirstView));  
        var notification = new Notification(Android.Resource.Drawable.Icon, title);  
        notification.Flags = NotificationFlags.AutoCancel;  
        notification.SetLatestEventInfo(this, title, desc, PendingIntent.GetActivity(this, 0, uiIntent, 0));  
  
        notificationManager.Notify(1, notification);  
    }  
  
    protected override void OnError(Context context, string errorId)  
    {  
        //Manage errors  
    }  
  
    protected override void OnUnRegistered(Context context, string registrationId)  
    {  
        //Manage unregistering services.  
    }  
}

You can see four important methods in this class: OnRegistered, OnMessage, OnError and OnUnRegistered:

• OnRegistered is executed when you register the application with the GcmClient class Register method.
• OnMessage is executed when a new notification is received. Here the code processes the received message and shows it as a toast notification.
• OnError, launches if an error is encountered.
• OnUnRegistered, executes when this instance is unregistered.

iOS

In iOS you will work in the AppDelegate class. In the first place, you need to add a new component to your iOS project, in the same way you did before with Google Cloud Messaging Client for Android. This time you also need to find the Azure Mobile Services component.

Also, we need to add a reference to the WindowsAzure.Messaging library for iOS. At this time there isn't a NuGet package available for this, but the Android NuGet Package of Xamarin.NotificationHub is included in the monotouch folder, so you can pick it right from there. The complete name of the library is ByteSmith.WindowsAzure.Messaging.iOS.dll.

Now you can start adding code to the AppDelegate class in your iOS project. First, add a call to RegisterForRemoteNotificationTypes to the FinishedLaunching method:

UIApplication.SharedApplication.RegisterForRemoteNotificationTypes(notificationTypes); 

Then call the method RegisteredForRemoteNotifications is called, so you need to override it:

public override async void RegisteredForRemoteNotifications(UIApplication application, NSData deviceToken)  
{  
    Hub = new NotificationHub(ConnectionString, NotificationHubPath);  
    await Hub.UnregisterAllAsync(deviceToken.ToString());  
    await Hub.RegisterNativeAsync(deviceToken.ToString());  
}

When a new notification is received, the method ReceivedRemoteNotification is called with the needed info so you can process the notification:

public override void ReceivedRemoteNotification(UIApplication application, NSDictionary userInfo)  
{  
    ProcessNotification(userInfo, false);  
}  
  
void ProcessNotification(NSDictionary options, bool fromFinishedLaunching)  
{  
    // Check to see if the dictionary has the aps key.  This is the notification payload you would have sent  
    if (options != null && options.ContainsKey(new NSString("aps")))  
    {  
        //Get the aps dictionary  
        NSDictionary aps = options.ObjectForKey(new NSString("aps")) as NSDictionary;  
  
        string alert = string.Empty;  
  
        if (aps.ContainsKey(new NSString("alert")))  
            alert = (aps[new NSString("alert")] as NSString).ToString();  
  
        //If this came from the ReceivedRemoteNotification while the app was running,  
        // we of course need to manually process things like the sound, badge and alert.  
        if (!fromFinishedLaunching)  
        {  
            //Manually show an alert  
            if (!string.IsNullOrEmpty(alert))  
            {  
                UIAlertView avAlert = new UIAlertView("Notification", alert, null, "OK", null);  
                avAlert.Show();  
            }  
        }  
    }  
}

And that is all you need to do with the client apps. Now let's move to the server side.

Server

In this sample source code, you will find a little WPF application acting as the server. This WPF app only has three buttons, to launch a notification to every platform registered. To make this, you need to add two NuGet packages to the project:

• Microsoft.WindowsAzure.ConfigurationManager
• WindowsAzure.ServiceBus

Installing WindowsAzure.ServiceBus, installs automatically the other one as part of the dependencies. After the installation, you can start writing the "backend" code. For example, this code launches a notification for WNS:

private async void Send_Windows(object sender, RoutedEventArgs e)  
{  
    NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString("<FULLSHAREDACCESS ENDPOINT>", "nhsampledemo");  
    var toast = @"<toast><visual><binding template=""ToastText01""><text id=""1"">Hello from a .NET App!</text></binding></visual></toast>";  
    await hub.SendWindowsNativeNotificationAsync(toast);  
}

This one launches a notification for Android using Google Cloud Messaging:

private async void Send_Android(object sender, RoutedEventArgs e)  
{  
    NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString("<FULLSHAREDACCESS ENDPOINT>", "nhsampledemo");  
    var message = "{ \"data\" : {\"msg\":\"Hello from Azure!\"}}";  
    var result = await hub.SendGcmNativeNotificationAsync(message);  
}

And finally this is the iOS one:

private async void Send_iOS(object sender, RoutedEventArgs e)  
{  
    NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString("<FULL ENDPOINT>", "nhsampledemo");  
    var alert = "{\"aps\":{\"alert\":\"Hello from .NET!\"}}";  
    await hub.SendAppleNativeNotificationAsync(alert);  
} 

In all three cases, you need to create a new NotificationHubClient, using the name of the notification hub (nhsampledemo) and the Full access connection string you get from the Notification Hub dashboard before. Then you create the notification payload and use a method specific for each platform to send the notification to the Notifications Hub, who sends it to the needed platform.

To learn more details about how to write various notifications for each platform, you can have a look here:

• Google Cloud Messaging format: https://developer.android.com/google/gcm/http.html
• Windows Notification Service: https://msdn.microsoft.com/en-us/library/windows/apps/br230849.aspx
• Apple Push Notification Service: https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/ApplePushService.html

And that's all! Now you have a Xamarin solution with notifications and understand how to create and configure an Azure Notifications Hub to use it with your cross platform solutions.

All the code for this example is available publicly in GitHub, feel free to use it any way you need.