Tag Archives: Xamarin Forms Google Analytics

Google Analytics tracking implementation in Xamarin …

It all began a while back when my boss tasked me to implement Google Analytics Tracking in one of the enterprise mobile applications we were developing using Xamarin platform, and to be specific the whole app was based on Xamarin Forms platform, harnessing the true cross platform abilities of Xamarin…

Since the first day of the development, it’s been a bit hard but a massive learning curve, due to the lack of articles regarding Google Analytics implementation in Xamarin, specifically Xamarin Forms. And yes, I did go through some back and forth mess, as for the lack of resources… But somehow I managed to successfully implement Google Analytics Tracking in our Xamarin based enterprise application.

Therefore I decided to share the experience and the knowledge I gained, with our fellow Xamarin Developer Community and ultimately save the precious time of a another developer, with the hopes of filling the gap of the lack of articles in Google Analytics implementation in Xamarin. 🙂 So here is the series of articles I wrote in that pursue…

Google Analytics implementation in Xamarin Android –

Let’s add Google Analytics to your Xamarin Android App ^_^

Untitled-1

https://theconfuzedsourcecode.wordpress.com/2015/07/06/lets-add-google-analytics-to-your-xamarin-android-app-_/

Google Analytics implementation in Xamarin iOS –

Let’s add Google Analytics to your Xamarin iOS App ^_^

Untitled-2

https://theconfuzedsourcecode.wordpress.com/2015/07/09/lets-add-google-analytics-to-your-xamarin-ios-app-_/

Google Analytics implementation in Windows Phone –

Let’s add Google Analytics to your Windows Phone App ^_^

Untitled-3

https://theconfuzedsourcecode.wordpress.com/2015/07/17/lets-add-google-analytics-to-your-windows-phone-app-_/

Google Analytics implementation in Xamarin Forms –

Okay Finally, Let’s add Google Analytics to Xamarin Forms …

Untitled-1

https://theconfuzedsourcecode.wordpress.com/2015/07/18/okay-finally-lets-add-google-analytics-to-xamarin-forms/

Well there it goes… Google Analytics tracking implementation in Xamarin ! 🙂

Well there it goes folks, hope this post was helpful for you and prolly saved you a lot of time… 🙂 Please share this among other developers as there aren’t much tutorials on Google Analytics tracking for Xamarin, and you may save another developer’s precious time as well… 😉

Cheers ! Stay Awesome ^_^ !

Advertisements

Okay Finally, Let’s add Google Analytics to Xamarin Forms …

Okay Finally ? O.o Wait ! Let me get to that… After my previous two posts on Google Analytics implementation on Xamarin AndroidXamarin iOS, and Windows Phone I thought of completing this series of posts with Google Analytics implementation on Xamarin Forms, a final frontier for the true awesomeness Xamarin cross platform-ability… 😉 If you haven’t gone through the previous three posts, it’s alright ! I’m writing this article with everything  necessary for someone to start from scratch for Xamarn Forms implementation of Google Analytics.. 🙂 

Untitled-1

Google Analytics is a great way to track your User’s activities in your website or application. We all know that Google has given an extensive support for Websites and and native mobile applications implementation of Google Analytics. But what about Cross Platform applications ? Specially when it comes to our beloved Xamarin (Xamarin Forms) ?

Official component, and a catch eh ?

Now if you take a look at the official Google Analytics component for Xamarin… You may find a not-so-little catch there…

https://components.xamarin.com/view/googleanalytics

Untitled2

Hope you saw the catch…

It’s only available for Xamarin iOS ! 😦 What about Xamarin Android, Windows Phone ? and specially awesome Xamarin Forms ??? That’s quiet not so fair.. lol

And yes just like you, I have been going through the same puzzled moment… So I looked for 3rd party libraries for implementing Google Analytics in Xamarin Forms.

In Search for 3rd party Libraries…

I was very surprised to see how hard it was to find third party libraries for Xamarin Forms Google Analytics implementation. But after a deep searching I came across two libraries.

1. FrazzApps’ Google Analytics Connector

First of all I came across this library called FrazzApps’ Google Analytics Connector

https://www.nuget.org/packages/FrazzApps.Xamarin.Forms.GoogleAnalyticsConnector/

but unfortunately it was still on the Alpha release level, and when I looked into its’ code, I saw that they were using the Analytics Measurement Protocol which is used for parsing parameters through a URL to Google Analytics in order to track the activities.

This has a disadvantages, as we are passing parameters through a URL the Google Analytics server wouldn’t have any idea about the context of the application, such as from what kind of a device environment these tracking information are coming from and so on. But this library is certainly great for simple tracking. I’m pretty sure this will be a great use for Xamarin Forms once its completely developed.

2. Google Analytics SDK for Windows 8 and Windows Phone

Finally I found about this Library which was previously used for Windows Phone based Google Analytics tracking, this also supports Xamarin PCL projects.

https://googleanalyticssdk.codeplex.com/

This seem to be a quite promising library but I had some trouble implementing it, and I wanted to try out native Google Analytics implementation with Xamarin, so I decided to drop it for now and move on. Even though I strongly recommend you give a try for this library, please share your feedback with me if any of you were able to implement this.

Decision Time…

With almost no proper library support for implementing Google Analytics in Xamarin Forms, I was hopeless. But something struck me,

I was abIe to natively implement Google Analytics on Xamarin Android and Xamarin iOS ! As well as on Windows Phone, using separate libraries…

What if call those natively implemented functionalities from our Xamarin Forms PCL code ? Well thanks to the mighty Dependency Service of Xamarin of course… 😉

PROBLEM SOLVED !!!!!! 😀

Likewise I decided to implement Google Analytics in my Xamarin Forms project natively and call the necessary functionalities using Xamarin Dependency Service from our PCL project code. So let’s get started….

(I’m gonna assume that you are already aware of DependencyService in Xamarin.Forms platform 🙂 )

Setting up the Stuff…

Before we begin coding we need to do some setting up of the libraries for our Xamarin Android, Xamarin iOS and Xamarin WinPhone. Below are the Libraries we will be using for Google Analytics implementation in our native projects projects…

Xamarin Android – Google Play Services
Capture

Xamarin iOS – Google Analytics for Xamarin iOS
Untitled2

Xamarin WinPhone – Google Analytics SDK for Windows 8 and Windows Phone
Untitled5

So let’s get started one by one…

Setting up the Stuff on Xamarin Android Project…

In simple terms open up your Nuget Package manager and search for “Google Play Services” and install it in your Xamarin Android project. If you manage to install without any issue, then you are good to go.

But for some this could be a pretty much tricky process, and if you come across any difficulties or issues, I have written a complete article on how to add the Google Play Services component into your Xamarin Android project. Please follow through it and come back here… 😉
https://theconfuzedsourcecode.wordpress.com/2015/06/25/how-to-add-google-play-services-to-your-xamarin-android-project/

Once you set up the Google Play Services library in your Xamarin Android project, make sure to add internet connectivity permission in you Android Manifest file… 🙂

Next let’s move on to your Xamarin iOS setting up…

Setting up the Stuff on Xamarin iOS Project…

This is a bit easy,  praise the official Google Analytics component for Xamarin iOS😉 Go ahead download it.. 
https://components.xamarin.com/view/googleanalytics

Once you have downloaded, we need to add the DLLs to your Xamarin iOS project References. You can do that by navigating into the following path in the folder you downloaded and extracted the library files to, which should be something similar to this “C:\…\googleanalytics-3.0.12\googleanalytics-3.0.12\lib\ios-unified\”. Add the “GoogleAnalytics.iOS.dll” to your project references.

Please note that this is for the Xamarin iOS Unified SDK, not for the classic SDK ! 🙂 I wouldn’t be going into the class sdk as everyone is migrating to the ios unified SDK.

Setting up the Stuff on Xamarin WinPhone Project…

For Xamarin WinPhone open up your Nuget Package manager and search for “GoogleAnalyticsSDK” and easily install Google Analytics SDK for Windows 8 and Windows Phone in your Xamarin WinPhone project.

Unlike in other two platforms we need to configure our Google Analytics Tracker info into this library through a file, for that open up the “analytics.xml” file which was automatically being created by the library we just installed. This xml file is very important because the library will set up itself automatically through the configurations we insert through this file.

Untitled1

Go ahead and add the necessary information, and specially no matter what add your Google Analytics Mobile App Tracking code.

Untitled7

Also this xml file allows us to set up a whole list of configuration for our App tracking, and I’ll show you some of the most important configurations you need to pay attention to.

Untitled8

I have enabled the automated Exceptions tracking, in which case I don’t need to track every single exception that occurs in the application manually, but you can also set it to false on your choice. The rest of the two Properties Advertising Id Collection, Auto Activity Tracking can be enabled or disabled upon your choice.

Untitled9

There up above as you can see I have set the Local dispatch period to “10”, which means all the tracking data will be automatically uploaded to the online GA service in every 10 seconds, this is a good approach considering we shouldn’t exhaust the network resources by uploading tracking information every single second. You can change the value to anything you wish but I recommend you keep it around this value.

Well that concludes the Setting up of the libraries in your native projects… 🙂 Let’s dive into Coding… 😉

Let the Coding begin…

As you have already learned in Xamarin in order to call the Native platform code, we need to use the Xamarin Dependency Service. Whereas here also we going to do the same, let’s start with the PCL project code implementation…

Let the Xamarin PCL Project Coding begin…

So to get started, let’s first of all implement the interface class in your PCL project we are going to be using with Xamarin Dependency Service…. Create the IGAService interface class as following…

namespace WhateverYourNamespace.Services
{
	public interface IGAService
	{
		void Track_App_Page(String PageNameToTrack);

		void Track_App_Event(String GAEventCategory, String EventToTrack);

		void Track_App_Exception(String ExceptionMessageToTrack, Boolean isFatalException);
	}
}

 

I have added three methods that I’m going to implement in the native projects, Tracking Page Views, Tracking Events, Tracking Exceptions… And you can see I have defined some parameters in those methods, I have added them because those information are required when we pass the data to the Google Analytics. Those method usage and parameters will be discussed step by step later…

In Google Analytics order to track any Event, such as a button click, check box selection and son on, you can use the following method.

In order to track an Event in Google Analytics, we need to have an Event Category, therefore we need to create a small struct along with the type of categories you need to track, this actually depends completely upon your requirement. You can have types of event categories such as. “Sales”, “Order”, “Shopping Cart” and so on… 🙂

public struct GAEventCategory
{
	public static String Category1 { get { return "Category1"; } set { } }
	public static String Category2 { get { return "Category2"; } set { } }
	public static String Category3 { get { return "Category3"; } set { } }
};

 

Whenever we are calling the  Track_App_Event() method, we will be passing the above struct values for the GAEventCategory parameter.

I kept a separate class to handle all the Google Analytics, where as I recommend you should do the same, which will make it easier.. 😉 Go ahead and create GAService class. In this class we are gonna implement all the GA functionalities we need to execute, whereas those methods will be calling the necessary IGAService interface methods through Xamarin Dependency Service…

// Google Analytics Services access point
public class GASConnect
{
	public static void Track_App_Page(String PageNameToTrack)
	{
		DependencyService.Get<IGAService>().Track_App_Page(PageNameToTrack);
	}

	public static void Track_App_Event(String GAEventCategory, String EventToTrack)
	{
		DependencyService.Get<IGAService>().Track_App_Event(GAEventCategory.ToString(), EventToTrack);
	}

	public static void Track_App_Exception(String ExceptionMessageToTrack, Boolean isFatalException)
	{
		DependencyService.Get<IGAService>().Track_App_Exception(ExceptionMessageToTrack, isFatalException);
	}
}

 

Well that’s the initial coding for Xamarin PCL project… 😉

Go ahead and Build your PCL project, next let it get into our Native project code implementation. We need to implement our IGAService interface in our native platform projects…

Let the Xamarin Android Project Coding begin…

Let’s start with Xamarin Android, you need to implement the IGAService interface, for that create GAService class…

[assembly: Dependency(typeof(WhateverYourNamespace.Droid.Services.GAService))]

namespace WhateverYourNamespace.Droid.Services
{
    public class GAService : IGAService
    {
        public string TrackingId = "XX-XXXXXXXX-X";

        private static GoogleAnalytics GAInstance;
        private static Tracker GATracker;
		
		#region Instantiation ...
        private static GAService thisRef;
        public GAService()
        {
            // no code req'd
        }

        public static GAService GetGASInstance()
        {
            if (thisRef == null)
                // it's ok, we can call this constructor
                thisRef = new GAService();
            return thisRef;
        }
        #endregion
        
        public void Initialize_NativeGAS(Context AppContext = null)
        {
            GAInstance = GoogleAnalytics.GetInstance(AppContext.ApplicationContext);
            GAInstance.SetLocalDispatchPeriod(10);

            GATracker = GAInstance.NewTracker(TrackingId);
            GATracker.EnableExceptionReporting(true);
            GATracker.EnableAdvertisingIdCollection(true);            
        }
    }
}

 

As for initializing we need to have instances with in this class as below and make sure to add the tracking code you get from your Google Analytics dashboard to the TrackingId value…

We are going to initialize the Google Analytics tracking service by calling the Initialize_NativeGAS() method, and for that we need to have a reference for the Android Context of your application, therefore we pass in the current Android Context as a parameter as shown above.

There up above as you can see I have set the Local dispatch period to “10”, which means all the tracking data will be automatically uploaded to the online GA service in every 10 seconds, this is a good approach considering we shouldn’t exhaust the network resources by uploading tracking information every single second. You can change the value to anything you wish but I recommend you keep it around this value.

I have enabled the automated Exceptions tracking, in which case I don’t need to track every single exception that occurs in the application manually, but you can also set it to false on your choice as well as the Property Advertising Id Collection.

Now that we have initialized our Google Analytics natively, let’s implement the rest of the methods. Add the method implementations as follows… Make sure your final implementation is as follows…

[assembly: Dependency(typeof(WhateverYourNamespace.Droid.Services.GAService))]

namespace WhateverYourNamespace.Droid.Services
{
    public class GAService : IGAService
    {
        public string TrackingId = "XX-XXXXXXXX-X";

        private static GoogleAnalytics GAInstance;
        private static Tracker GATracker;
		
		#region Instantiation ...
        private static GAService thisRef;
        public GAService()
        {
            // no code req'd
        }

        public static GAService GetGASInstance()
        {
            if (thisRef == null)
                // it's ok, we can call this constructor
                thisRef = new GAService();
            return thisRef;
        }
        #endregion
        
        public void Initialize_NativeGAS(Context AppContext = null)
        {
            GAInstance = GoogleAnalytics.GetInstance(AppContext.ApplicationContext);
            GAInstance.SetLocalDispatchPeriod(10);

            GATracker = GAInstance.NewTracker(TrackingId);
            GATracker.EnableExceptionReporting(true);
            GATracker.EnableAdvertisingIdCollection(true);
            GATracker.EnableAutoActivityTracking(true);
        }

        public void Track_App_Page(String PageNameToTrack)
        {
            GATracker.SetScreenName(PageNameToTrack);
            GATracker.Send(new HitBuilders.ScreenViewBuilder().Build());
        }

        public void Track_App_Event(String GAEventCategory, String EventToTrack)
        {
            HitBuilders.EventBuilder builder = new HitBuilders.EventBuilder();
            builder.SetCategory(GAEventCategory);
            builder.SetAction(EventToTrack);
            builder.SetLabel("AppEvent");

            GATracker.Send(builder.Build());
        }

        public void Track_App_Exception(String ExceptionMessageToTrack, Boolean isFatalException)
        {
            HitBuilders.ExceptionBuilder builder = new HitBuilders.ExceptionBuilder();
            builder.SetDescription(ExceptionMessageToTrack);
            builder.SetFatal(isFatalException);

            GATracker.Send(builder.Build());
        }
    }
}

 

Now I’m not going to explain the method implementation of Page Views, Events and Exceptions tracking each line by line, otherwise this article would be too long. If you need more descriptive explanation please refer to my article on Google Analytics implementation Xamarin Android article..

Untitled-1Google Analytics implementation Xamarin Android article..

For further reading…

 

Also we to call the initialization method at the application start in Xamarin Android project level, for that change your OnCreate method in MainActivity class as follows…

protected override void OnCreate(Bundle bundle)
{
	base.OnCreate(bundle);

	global::Xamarin.Forms.Forms.Init(this, bundle);

	GAService.GetGASInstance().Initialize_NativeGAS(this);

	LoadApplication(new App());
}

 

Aaaand you are done with Xamarin Android implementation.. 🙂

Let the Xamarin iOS Project Coding begin…

Here also we are going to follow the same implementation procedure… We are going to implement the IGAService interface, for that create GAService class.

I’m not going to explain the initialization code step by step as I have done before, just keep in mind its the same concept of setting the Tracking Code, Dispatch Interval, and Uncaught Exception tracking properties and so on… So I’m going to jump into the full implemenation including the methods…

[assembly: Dependency(typeof(WhateverYourNamespace.iOS.Services.GAService))]

namespace WhateverYourNamespace.iOS.Services
{
    public class GAService : IGAService
    {
        public string TrackingId = "XX-XXXXXXXX-X";

        public IGAITracker Tracker;
        const string AllowTrackingKey = "AllowTracking";

        #region Instantition...
        private static GAService thisRef;
        public GAService()
        {
            // no code req'd
        }

        public static GAService GetGASInstance()
        {
            if (thisRef == null)
                // it's ok, we can call this constructor
                thisRef = new GAService();
            return thisRef;
        }
        #endregion

        public void Initialize_NativeGAS()
        {
            var optionsDict = NSDictionary.FromObjectAndKey(new NSString("YES"), new NSString(AllowTrackingKey));
            NSUserDefaults.StandardUserDefaults.RegisterDefaults(optionsDict);

            GAI.SharedInstance.OptOut = !NSUserDefaults.StandardUserDefaults.BoolForKey(AllowTrackingKey);

            GAI.SharedInstance.DispatchInterval = 10;
            GAI.SharedInstance.TrackUncaughtExceptions = true;

            Tracker = GAI.SharedInstance.GetTracker("Test App", TrackingId);
        }

        public void Track_App_Page(String PageNameToTrack)
        {
            GAI.SharedInstance.DefaultTracker.Set(GAIConstants.ScreenName, PageNameToTrack);
            GAI.SharedInstance.DefaultTracker.Send(GAIDictionaryBuilder.CreateScreenView().Build());
        }

        public void Track_App_Event(String GAEventCategory, String EventToTrack)
        {
            GAI.SharedInstance.DefaultTracker.Send(GAIDictionaryBuilder.CreateEvent(GAEventCategory, EventToTrack, "AppEvent", null).Build());
            GAI.SharedInstance.Dispatch(); // Manually dispatch the event immediately
        }

        public void Track_App_Exception(String ExceptionMessageToTrack, Boolean isFatalException)
        {
            GAI.SharedInstance.DefaultTracker.Send(GAIDictionaryBuilder.CreateException(ExceptionMessageToTrack, isFatalException).Build());
        }
    }
}

 

We don’t need to pass in any context parameters or anything to our Initialize_NativeGAS() method like we did in Xamarin Android. Because in Xamarin iOS GA library it keeps a static shared instance of the GA tracking service where we can easy access.

As you can see above I have used the previously explained AllowTrackingKey variable to give the user option to opt out from the Tracking events by adding it to the SharedUserDefaults.

The method implementation is almost the same as Xamarin Android, but only the keywords and syntaxes are different.  If you need more descriptive explanation on the above code implementation please refer to my article on Google Analytics implementation Xamarin iOS article..

Untitled-2Google Analytics implementation Xamarin iOS article..

For further reading…

 

Also we need to call the initialization method at the application start in Xamarin iOS project level, You need to modify your FinishedLaunching method as follows,

public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
	global::Xamarin.Forms.Forms.Init();

	GAService.GetGASInstance().Initialize_NativeGAS();

	LoadApplication(new App());

	return base.FinishedLaunching(app, options);
}

 

Aaaand you are done with Xamarin iOS implementation.. 🙂

Let the Xamarin WinPhone Project Coding begin…

Here also we are going to follow the same implementation procedure… We are going to implement the IGAService interface, for that create GAService class.

I’m not going to explain the initialization code step by step as I have done before, just keep in mind its the same concept of setting the Tracking Code, Dispatch Interval, and Uncaught Exception tracking properties and so on… So I’m going to jump into the full implemenation including the methods…

[assembly: Dependency(typeof(WhateverYourNamespace.WinPhone.Services.GAService))]

namespace WhateverYourNamespace.WinPhone.Services
{
    public class GAService : IGAService
    {
        #region Instantition...
        private static GAService thisRef;
        public GAService()
        {
            // no code req'd
        }

        public static GAService GetGASInstance()
        {
            if (thisRef == null)
                // it's ok, we can call this constructor
                thisRef = new GAService();
            return thisRef;
        }
        #endregion

        public void Initialize_NativeGAS()
        {
            // No requirement for initializing in Windows Phone, its done by the 
            // library itself using the values given in the analytics.xml file
        }

        public void Track_App_Page(String PageNameToTrack)
        {
            GoogleAnalytics.EasyTracker.GetTracker().SendView(PageNameToTrack);
        }

        public void Track_App_Event(String GAEventCategory, String EventToTrack)
        {
            GoogleAnalytics.EasyTracker.GetTracker().SendEvent(GAEventCategory, EventToTrack, "AppEvent", 0);
        }

        public void Track_App_Exception(String ExceptionMessageToTrack, Boolean isFatalException)
        {
            GoogleAnalytics.EasyTracker.GetTracker().SendException(ExceptionMessageToTrack, isFatalException);
        }
    }
}

 

As you may have noticed above, we have left our Initialize_NativeGAS() method as empty, unlike in our Xamarin Android and iOS implementations where we initialized all the GA library components. It is because GA Library we have used for Xamarin WinPhone project, takes care of all that configuration and initialization by itself, with the help of the  “analytics.xml” file, which we configured at the beginning of this tutorial.

If you need more descriptive explanation on the above code implementation please refer to my article on Google Analytics implementation Windows Phone article..

Untitled-3

Google Analytics implementation Windows Phone article..

For further reading…

 

 

Aaaand you are done with Xamarin WinPhone implementation.. 🙂

Well that concludes all our Native Platform implementation, next let’s see how we could use this implementation in our PCL project… 🙂

Finally let’s FIRE IT UP… ! 😉

Well as our IGAService and its native GAService classes is ready to be called in through Xamarin Dependency Service,  let’s see how to access it and start tracking our App. 🙂

Here is how you could use our above class for Page Tracking, Event Tracking and Exception Tracking.

Let’s track a Page View…

Wherever you want to track a page view in your app, call our GASConnect class Track_App_Page() method in your PCL Project and pass in the Page Name as you wish… Yep it’s that easy, after all that implemenation..

// Track a page
GASConnect.Track_App_Page("Home Page");

 

Furthermore I suggest you do that in the ContentPage’s Appearing event such as below..

// Call the method in Page Appearing event
public class Page_Home : ContentPage 
{
	public Page_Home()
	{
	
		this.Appearing += (sender, e) =>
		{
			GASConnect.Track_App_Page("Home Page");
		};
	}
}

Let’s track an Event…

Wherever you want to track an event in your app, call our GASConnect class Track_App_Event() method in your PCL Project and pass in the Event Category Type and Descirption as you wish…

// Track an event
GASConnect.Track_App_Event(GAEventCategory.Category1, "hey ! Category 1 type event ocurred !");   

// Track an event
GASConnect.Track_App_Event(GAEventCategory.Category1, "hey ! Category 2 type event ocurred !");   

 

Let’s track an Exception…

Wherever you want to track an exception in your app, call our GASConnect class Track_App_Exception() method in your PCL Project and when you pass in the Exception message, you can either take the whole ex.StackTrace() or ex.Massage() or both together as a value of your exception in anyway you wish…

// Track an Exception
GASConnect.Track_App_Exception(ex.Message, false); 

 

After calling those methods you will be able to see the live tracking information in your Google Anlytics Dashboard online. Just log in to the Real-Time Overview  and you will be able to see everything there. Just keep in mind, as there is a dispatch period of 10 seconds, it might take a while for the actual tracking data to be displayed in the Real-Time tracking view in Google Analytics… 🙂

Well there it goes folks, hope this post was helpful for you and prolly saved you a lot of time… 🙂 Please share this among other developers as there aren’t much tutorials on Google Analytics tracking for Xamarin Forms, and you may save another developer’s precious time as well… 😉

Cheers ! Stay Awesome ^_^ !