![\"Xcode](\"https:\/\/img.shields.io\/badge\/Xcode-7.3-blue.svg?style=flat\")
![\"Swift](\"https:\/\/img.shields.io\/badge\/Swift-2.2-orange.svg?style=flat\")
<\/p>\n <\/p>\n
Mobile application analytics is the capture and analysis of what users are doing with your mobile app. Of course, it is a subcategory of all overall application usage analytics which covers the OS, desktop applications, web usage, and so on. Up until earlier this year, Parse<\/a> was a popular cloud platform for capturing and displaying mobile app usage data.<\/p>\n There are a few lessons to be learned from Parse’s abrupt departure from the scene. Foremost, and this should come as no surprise to anyone who has done software development for more than year, nothing is forever<\/i>. Things change. The second lesson could be, once you’ve experienced the aggravation (or pain) of changing out one framework for another, why not abstract the underlying operations a little bit and make it easier to change in the future? We’re going to take that lesson and apply it to mobile analytics and show how you can “future proof” your application a bit.<\/p>\n Apple’s introduction to protocols<\/a> contains a very succinct definition as to what a protocol is: a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality.<\/i> Think about how we can use that definition to define an analytics event logger<\/i> protocol. There are a few very basic methods that any logger should provide:<\/p>\n Certainly, you could go through the various analytics platform providers and find a wide variety of features, but at the core we would like to see at least these three. Perfect candidates for a protocol definition:<\/p>\n By itself the Amplitude<\/a> was the first mobile analytics service we came across when looking to migrate Bondi<\/a> away from Parse. It had a straightforward (and free) signup process combined with a simple API for logging events. The implementation of an CleverTap<\/a> is another<\/i> mobile analytics service that provides for fast sign up and registration. Truth be told, we found the actual integration of the CleverTap SDK into our application to be a bit more cumbersome. We’ll get to the reasons why in a moment, but for the sake of completeness, here is what an event logger based upon CleverTap might look like:<\/p>\n The key thing to notice here is that the protocol<\/i> dictates the methods:<\/p>\n The underlying implementation for an event logger based upon Amplitude will use Amplitude SDK methods. The implementation of the protocol based upon CleverTap will use CleverTap SDK methods.<\/p>\n Note:<\/b>Many mobile analytics services provide many more methods than this. For example, some provide heatmap analysis of where on the screen the user is touching. Our goal here is not to build a protocol that encompasses all<\/i> types of mobile analytics features, but a subset of those that we’ve found particularly useful.<\/p>\n We’ve put together a quick demonstration application that allows for you to use either Amplitude or CleverTap for event logging. This section<\/i> is a walkthrough of the demonstration application with guidance on where to plug in your API keys. You will, however, have to actually sign up for the services online to run the app!<\/p>\n The event logger itself is kept as the instance member In the above code we declare an And in truth, you don’t even need to declare the variable type ( Get the demonstration application source from BitBucket with The key files to review in the demonstration project are:<\/p>\n Most, if not all, analytics platform will have you use either a single application key or combination of account identifier and application key. Amplitude and CleverTap are no different. The sample application utilizes property lists<\/a> for managing API keys<\/a>. If you haven’t<\/i> signed up for any service, jump down to the sections on signing up for Amplitude<\/a> or CleverTap<\/a> and register for the services.<\/p>\n Notice that the Create the Add keys for Once the API keys are in place, update the Pressing on the Like<\/b>, Dislike<\/b>, etc. buttons will call the mobile analytics logging methods (see the Note:<\/b> This a quick introduction to signing up for Amplitude and is not meant to be a full-featured tutorial on all of its features.<\/p>\n First, you’ll need to sign up for Amplitude on their sign up<\/a> page. Fill in all of the required information (name, email, etc.), and get greeted with a Welcome to Amplitude<\/b> dialog.<\/p>\n Click on the Let’s Go<\/b> button and create your first application. We’re going to put in our organization as iAchieved.it LLC and the application will be Appname Development<\/b>. There will be different “keys” for development vs. release applications.<\/p>\n Click Continue<\/b> and select the iOS SDK and click I’m Ready to Install<\/b>. Amplitude will present a Install the Amplitude SDK<\/b> page which provides a set of instructions for downloading the iOS SDK, updating your projects build settings to include SQLite, and then showing an Objective C example of invoking the service. We’re passionate about using Swift for applications, so at this stage click on the Download the source code<\/a> link to pull down the iOS source for Amplitude. Unzip the downloaded folder.<\/p>\n The demonstration application provided already contains the Amplitude SDK, but if you were starting a new project drag and drop the Back in the Amplitude portal you can just click Continue<\/b> on the Install Amplitude SDK<\/b> page and then click Done<\/b>, and then when prompted to invite members to your team click Skip<\/b>.<\/p>\n Add the following frameworks to your Xcode Project:<\/p>\n Frameworks are easily added by going to your project target application and then selecting Build Phases<\/b>, then going to the Link Binary With Libraries<\/b> and then using the +<\/b> icon to select the framework.<\/p>\n At iAchieved.it we’ve been using Swift since the day it came out and haven’t looked back. If you too are developing your applications with Swift you’ll need to add a bridging header<\/i> to your project to access the Amplitude API. Bridging headers are easy to add. First, use File – New – File<\/b> and select iOS Source<\/b>, and then find the Header file<\/b> icon. Name the file Next, go to your application target and click on Build Settings<\/b>. Type Double-click on the line that says Objective-C Bridging Header<\/b> and type into the dialog box Now, in the The API credentials you will need for your application are easy to find in Amplitude. In the web portal, click on the account e-mail in the upper-right and select Account Settings<\/b> in the dropdown menu.<\/p>\n In our demonstration application we’re using the Note:<\/b> This a quick introduction to signing up for CleverTap and is not meant to be a full-featured tutorial on all of its features.<\/p>\n We found working with CleverTap to be a little less intuitive than Amplitude. Nevertheless, it doesn’t require a credit card to get started which makes it easy to try-before-you-might-buy.<\/p>\n Sign up with CleverTap by heading over to Sign Up<\/a> page and filling out the required information. You’ll get an activation e-mail sent which contains a link to complete the sign up process. Find the e-mail and click on the Complete your signup<\/b> button.<\/p>\n Click the Add my first app<\/b> button to take you to the next screen:<\/p>\n Notice that in CleverTap a TEST<\/b> environment automatically gets created for your application. Frankly I don’t<\/i> care for this feature because it makes assumptions about what your environments are named. With Amplitude you would manage your own development vs. staging vs. release applications, whereas CleverTap simply assumes you’ll have a TEST-<\/b> application.<\/p>\n Click on Add My App<\/b>. You’ll be presented with a screen where you can select which ecosystem you’re developing for (Android, iOS, Windows, etc.) and provide the AppStore URL for your application. Select iOS and click on Skip URL<\/b>.<\/p>\n Here too the integration instructions for CleverTap are not as straightforward as they could be. We suggest you click on Skip Integration<\/b> and then follow these instructions:<\/p>\n A download link to the CleverTap iOS SDK can be found on the iOS SDK integration page<\/a>. Choose the download for either Xcode 7 or Xcode 6, and a file named something like Add the following frameworks to your Xcode Project:<\/p>\n As with Amplitude, if you are using Swift you will want to add a bridging header. Refer back<\/a> for quick instructions on adding the header file. In the CleverTap tries to be a bit too clever with its API keys. There is a method that can be called, that it is clear you need to add two keys Note:<\/b> The Software developers are interesting creatures. We frequently want to rewrite things when there is a new language or framework to work with, yet we don’t necessarily care for changing things when its forced on us. There is also a desire to develop “systems” that are extensible and can adapt to tomorrow’s requirements. Our service-agnostic event logging follows the spirit of this approach, but even still one must recognize that tomorrow’s mobile analytics platforms will provide us with new features and capabilities that require adapting to if they are to be utilized. In other words, the approach we used here is by no means the final story, and as new services are evaluated we must always be prepared to rework areas of the code that are no longer capable of fitting our needs. Even still, after you’ve been through the headache of changing APIs due to one reason or another (your favorite API is abandoned<\/a>, isn’t Swifty enough for you<\/a>, or otherwise end-of-lifed like Parse), you might consider using a protocol-based approach to provide a neutral shim between you and another service.<\/p>\n","protected":false},"excerpt":{"rendered":" Mobile application analytics is the capture and analysis of what users are doing with your mobile app. Of course, it is a subcategory of all overall application usage analytics which covers the OS, desktop applications, web usage, and so on. Up until earlier this year, Parse was a popular cloud platform for capturing and displaying […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11,5],"tags":[],"class_list":["post-2685","post","type-post","status-publish","format-standard","hentry","category-apple","category-swift"],"_links":{"self":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2685"}],"collection":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/comments?post=2685"}],"version-history":[{"count":59,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2685\/revisions"}],"predecessor-version":[{"id":2761,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2685\/revisions\/2761"}],"wp:attachment":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/media?parent=2685"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/categories?post=2685"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/tags?post=2685"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Protocols<\/h2>\n
\n
\nimport Foundation\n\nprotocol AnalyticsEventLogger {\n \n func initialize()\n func logEvent(name:String)\n func logEvent(name:String, data:AnyObject)\n \n}\n<\/pre>\nAnalyticsEventLogger<\/code> protocol will not do anything, it is only the blueprint<\/i>. We will need an actual analytics framework to do the work.<\/p>\nAmplitude<\/h3>\n
AnalyticsEventLogger<\/code> protocol around Amplitude would be quite simple:<\/p>\n\nclass AmplitudeEventLogger : AnalyticsEventLogger {\n \n func initialize() {\n Amplitude.instance().initializeApiKey(AmplitudeApplicationKey)\n }\n \n func logEvent(name:String) {\n Amplitude.instance().logEvent(name)\n }\n \n func logEvent(name:String, data:AnyObject) {\n Amplitude.instance().logEvent(name, withEventProperties: data as! [NSObject : AnyObject])\n }\n\n}\n<\/pre>\nCleverTap<\/h3>\n
\nimport Foundation\n\nclass CleverTapEventLogger : AnalyticsEventLogger {\n \n func initialize() {\n CleverTap.changeCredentials(withAccountID: accountID, andToken: accountToken)\n }\n \n func logEvent(name:String) {\n CleverTap.sharedInstance().recordEvent(name)\n }\n \n func logEvent(name:String, data:AnyObject) {\n CleverTap.sharedInstance().recordEvent(name, withProps: data as! [NSObject:AnyObject])\n }\n \n}\n<\/pre>\n\n
initialize()<\/code>\nlogEvent(name:String)<\/code>\nlogEvent(name:String, data:AnyObject)<\/code>\n<\/ul>\nDemonstration Application<\/h2>\n
eventLogger<\/code> of the AppDelegate<\/code>.<\/p>\n\nclass AppDelegate: UIResponder, UIApplicationDelegate {\n var window: UIWindow?\n var eventLogger:AnalyticsEventLogger = AmplitudeEventLogger()\n\n func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {\n\n eventLogger.initialize()\n eventLogger.logEvent(AnalyticsStartEvent)\n \n return true\n }\n\n \/\/ Additional routines\n}\n<\/pre>\neventLogger<\/code> to be an instance of a class that adheres to the AnalyticsEventLogger<\/code> protocol. The actual instance will be an AmplitudeEventLogger<\/code> which we’ve outlined the implementation in the AmplitudeEventLogger.swift<\/code> file. If you want to change this out to use CleverTap, simply replace the definition with:<\/p>\n\nvar eventLogger:AnalyticsEventLogger = CleverTapEventLogger()\n<\/pre>\n
AnalyticsEventLogger<\/code>) here. The Swift compiler will figure this out.<\/p>\nGetting the Source<\/h3>\n
git clone git@bitbucket.org:iachievedit\/mobileanalytics.git<\/code> in a terminal. Open the appname.xcodeproj<\/code> project in Xcode.<\/p>\n![\"appname](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/appname_xcodeproj.png\")
<\/a>Project Basics<\/h3>\n
\n
AnalyticsEventLogger.swift<\/code> – this file contains our AnalyticsEventLogger<\/code> protocol that all “event loggers” will adhere to\nAmplitudeEventLogger.swift<\/code> – an implementation of the AnalyticsEventLogger<\/code> protocol using the Amplitude service is here\nCleverTapEventLogger.swift<\/code> – an implementation of the AnalyticsEventLogger<\/code> protocol using the CleverTap service is here\nEventConstants.swift<\/code> – event names for all of the backend services using Swift constant definitions\nViewController.swift<\/code> – our demonstration application logs analytics events when buttons are pressed on the screen. The IBAction<\/code> routines for these presses are in the view controller.\nApiKeys.swift<\/code> – this file contains a routine we use for extract API keys from a .plist<\/code> file. Details on how this is used is covered in the next section API Keys<\/b>!\n<\/ul>\nAPI Keys<\/h3>\n
ApiKeys.plist<\/code> file above is red. That means it is missing, so you’ll need to create one to add keys for the mobile analytics providers you choose. To be able to switch back and forth between the Amplitude and CleverTap you’ll need accounts and API keys for both. You can follow though the instructions below to obtain those, or, even use the starter application as a template to try out other services such as Flurry<\/a> or AppAnalytics<\/a>.<\/p>\nApiKeys.plist<\/code> file using Xcode File – New – File<\/b> and then select iOS Resource<\/b>, and choose the Property List<\/b> template. Click Next<\/b> and name the file ApiKeys.plist<\/code> and ensure that the dialog box includes adding it to the application target.<\/p>\nAmplitudeDevelopmentApplicationKey<\/code> etc., one for each key that you will need to reference in the project. If you follow through with this example and use Amplitude and CleverTap, your ApiKeys.plist<\/code> file should look something like this:<\/p>\n![\"ApiKeys.plist\"](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/ApiKeys_plist.png\")
<\/a>AppDelegate<\/code> to choose the logger you want to use and then run the application either on a phone or the simulator.<\/p>\n![\"Logging](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/appname.png\")
<\/a>ViewController.swift<\/code> file). In the case of the Donate<\/b> button the logged method will include the amount donated.<\/p>\nGetting Started with Amplitude<\/h2>\n
![\"AmplitudeAnalytics\"](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/AmplitudeAnalytics.png\")
<\/a><\/p>\n![\"SetupOrganizationAndApp\"](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/SetupOrganizationAndApp.png\")
<\/a><\/p>\nAmplitude<\/code> subfolder into your project. Make sure and select Copy items if needed<\/b>, Create groups<\/b>, and of course ensure your application target is selected.<\/p>\n![\"AddingAmplitude\"](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/AddingAmplitude.png\")
<\/a>Add Additional Frameworks<\/h3>\n
\n
Add a Bridging Header<\/h3>\n
bridgingHeader.h<\/code>.<\/p>\nbridging<\/code> into the search box to see something like:<\/p>\n![\"Bridging](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/bridgingheader.png\")
<\/a>$(SRCROOT)\/bridgingHeader.h<\/code>. The $(SRCROOT)<\/code> variable will be expanded to your project’s source root <\/a>.<\/p>\nbridgingHeader.h<\/code> add the line #import \"Amplitude.h\"<\/code>.<\/p>\nAPI Credentials<\/h3>\n
![\"Amplitude](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/AmplitudeApiKeys.png\")
<\/a>
<\/figcaption><\/figure>\n.plist<\/code> method for storing API keys, so take the appropriate key and add to the ApiKeys.plist<\/code> file. Alternatively you can put the API key directly in the Amplitude.instance.initializeApiKey<\/code> method in the AmplitudeEventLogger.swift<\/code> file.<\/p>\nGetting Started With CleverTap<\/h2>\n
![\"WelcomeToCleverTap\"](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/WelcomeToCleverTap.png\")
<\/a><\/p>\n![\"Add](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/AddYourApp2.png\")
<\/a>Obtain the CleverTap iOS SDK<\/h3>\n
CleverTapSDK-v2.0.10-20160405.framework.zip<\/code> will be placed in your Downloads<\/code> folder. Unzip the file and a single framework file CleverTapSDK.framework<\/code> will be there in the Downloads<\/code> folder. Drag and drop the CleverTapSDK.framework<\/code> file to your Xcode project ensuring that Copy items if necessary<\/b> and Create groups<\/b> is selected, and of course you will want to add it to your application target.<\/p>\nAdd Additional Frameworks<\/h3>\n
\n
Add a Bridging Header (If You’re Using Swift)<\/h3>\n
bridgingHeader.h<\/code> add the line #import <CleverTapSDK\/CleverTap.h><\/code>.<\/p>\nAPI Credentials<\/h3>\n
autoIntegrate<\/code>, that “registers everything” with the CleverTap backend. There are no arguments to the autoIntegrate<\/code> method and its only after looking closely at this<\/p>\n![\"CleverTap](\"http:\/\/dev.iachieved.it\/iachievedit\/wp-content\/uploads\/2016\/04\/cleverTapCredentials.png\")
<\/a>CleverTapAccountID<\/code> and CleverTapToken<\/code> to “your .plist<\/code> file”. One assumes that is referring to the Info.plist<\/code> file, but if you are going to manage a test application and regular application, juggling .plist<\/code> files in conditional builds is annoying. So rather than use the autoIntegrate<\/code> method you can use changeCredentials(withAccountID:andToken)<\/code>. This skips the auto-integration and need for using .plist<\/code> files to manage the API keys. Instead you can use something like:<\/p>\n\nlet accountID = valueForAPIKey(named:\"CleverTapDevelopmentAccountID\")\nlet accountToken = valueForAPIKey(named:\"CleverTapDevelopmentAccountToken\")\nCleverTap.changeCredentials(withAccountID: accountID, andToken: accountToken)\n<\/pre>\n
valueForAPIKey<\/code> routine comes from our post on managing API keys with property lists, but using this method you can determine the name of the key.<\/p>\nClosing Thoughts<\/h2>\n