Prerequisites and minimal setup

In this section, we explain how to get started with FollowAnalytics SDK for Android. Before you start, be sure to have all the necessary prerequisites. These include:

  • Registering the application on the Platform
  • Generating the API Key

Here are the minimal steps for integrating the SDK in your application:

Once the integration is finished, you can validate your setup, and start tagging events and saving attributes in your application.

Install using Gradle

The best way to install the SDK is with Gradle:

  1. Fetch the library from the private nexus repository

  2. Add the FollowAnalytics repository to your build.gradle repositories.

    repositories {
        maven {
            url ''
  3. Add the FollowAnalytics SDK to your module's build.gradle dependencies.

    dependencies {
        implementation ""

Once installation is over you will notice that dependencies and permissions are automatically added. For more information on dependencies and permissions, refer to the two subsections .


Using Gradle, dependencies will automatically be added while merging the manifest. The FollowAnalytics SDK depends on the following libraries:

implementation ""
implementation ""
implementation ""
implementation ""
implementation "me.leolin:ShortcutBadger:1.1.19@aar"

ShortcutBadger dependency

The ShortcutBadger dependency allows devices to display the number of unread messages on the app icon. These are called badges and, unlike on iOS, they are automatically managed with this dependency.


Automatically added permissions

Using Gradle, the SDK adds automatically the following permissions to your manifest.

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.WAKE_LOCK"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Additional permissions

Android M and permissions

The following permissions are labelled as dangerous since Android 6.0 Marshmallow (find more information about dangerous permissions here):

  • android.permission.ACCESS_COARSE_LOCATION
  • android.permission.ACCESS_FINE_LOCATION (for geofencing feature).

Permissions and user experience

Note that each permissions results in a dialog being shown to your user. Instead of having them appear at installation, you can have them appear at the most relevant location in your app during runtime. To include permissions and keep a good user experience, we recommend you to follow the Android guidelines described here.

Initialize with your API key

Prepare your API key

Be sure to have your API key for this step of the configuration. If you are not sure where to find it, reach out to your Customer Success Manager or message support.

To add your API key to your app project, add the following to your Manifest file, within the application tag:

   <meta-data android:name="FAID" android:value="YOUR_API_KEY"/>

To initialize the FollowAnalytics SDK use the onCreate() method of an Application class. This allows the SDK to be systematically initialized, whether the user launches the app himself, or if the Android system wakes a receiver or service of the app (for example, a push notification).

Open your Application subclass, or create a new one, and add the following lines to override the onCreate method:

public class MyAwesomeApplication extends Application {
    public void onCreate() {

If you just created an Application subclass, remember to declare it in your AndroidManifest.xml file:

    [...] />

Register for notifications


Push notifications on debug mode don't work. If you wish to test your notifications, which is highly recommended, switch to release mode.

The FollowAnalytics SDK supports push notifications based on Firebase Cloud Messaging. If you haven't done so already, you will need to add your project to Firebase in order to continue in the following steps. In this section we will explain to you how to use Firebase Cloud Messaging (or FCM) with the FollowAnalytics SDK. This means that we will cover:

Migrating from GCM to FCM

If your app already uses Google Cloud Messaging (GCM) for your push notifications, you will need to migrate to Firebase Cloud Messaging (FCM). To avoid issues migrating from GCM to FCM, FollowAnalytics will provide you with a new FCM key. To get your FCM Key, please contact your Customer Success Manager.

If you wish to use your own key for legacy apps and migrate to firebase, you can follow the instructions in the Advanced Use Cases section.

Install Firebase Cloud Messaging

Get started with Firebase (new applications only)

Sending push notifications for Android require an If you don't already use Firebase, you will need to do the following:

  • Add Firebase to your project
  • Create Firebase project to Firebase console

Before you start adding Firebase to your project, we recommend you take the time to familiarize yourself with firebase and its console. You will find this information (and much more) by referring to the Google documentation.

  1. Add the library FCM to your build.gradle file in your application module.

      implementation ""
  2. Create a class that extends to FirebaseMessagingService and override the two methods onMessageReceived and onNewToken.

    public class MyFirebaseMessagingService extends FirebaseMessagingService {
        * Every push notification will arrive through this method
        public void onMessageReceived(RemoteMessage remoteMessage) { }
        * Every new token will arrive through this method
        public void onNewToken(String s){ }
  3. Add the following service tag in your AndroidManifest application file. Be sure that the value in android:name is the relative path to your new service previously created.

        android:name=".MyFirebaseMessagingService"> <!-- Relative path of service class-->
            <action android:name=""/>
  4. Finally, do not forget to copy the FCM Server key token (available through Firebase Console in your project settings).

and paste it to our platform in the application's administration.

!!! warning "Verify your Google Services configuration" - Be sure that you have a version of Google Services that is at least 4.0.1 - Be sure that the JSON for Google Services in your application (accessible by doing select Project > App > google-services.json) is the same as the one in Firebase (which you can download from the Firebase Console)

Interacting Firebase Cloud Messaging with FollowAnalytics SDK

Now that you have installed FCM, you need it to interact with the FollowAnalytics SDK. For this, access the your Firebase Cloud Messaging Service class (a class we previously called MyFirebaseMessagingService that was created and extended to FirebaseMessagingService).

Set push token

For example:

public void onNewToken(String s){
    android.util.Log.d(TAG, "Token is : "+s);
    FollowAnalytics.setPushToken(s); // <-- Insert this method
Process Firebase Message

This function must be added to onMessageReceived in cases to transmit the push notification to FollowAnalytics SDK.

public void onMessageReceived(RemoteMessage remoteMessage) {
    FollowAnalytics.processFirebaseMessage(this, remoteMessage); // <-- Insert this method

Validate your setup


The SDK has a Validator that will ensure that everything is properly configured. To know more about what the validator can check and how, refer to its dedicated page.

Depending on how you wish to check your configuration with the Validator, use one of the two methods:


Events vs Attributes

The FollowAnalytics SDK allows you to tag both events and attributes. In this section, we explain how to utilize both of them in your app and benefit from analytics capabilities. If you are unsure about the difference, you may refer to the corresponding FAQ entry.

App logs

You can tag your app by adding logs to specific events and errors experienced by the user. These logs are then received and visible on the FollowAnalytics platform.

Logging best practices

To successfully empower your team with FollowAnalytics make sure your logs are relevant, read the Logging best practices entry in the FAQ section.

Regular, native logs

To add FollowAnalytics logs in your code, here are the two methods you can call from the SDK:

// Log an event without details
FollowAnalytics.logEvent(String eventName);
FollowAnalytics.logError(String errorName);

// Log an event with String details
FollowAnalytics.logEvent(String eventName, String details);
FollowAnalytics.logError(String errorName, String details);

// Log an event with Map details
// This is useful to pass pairs of key-values into a single event
FollowAnalytics.logEvent(String eventName, Map<String, String> details);
FollowAnalytics.logError(String errorName, Map<String, String> details);

Use the name as the unique identifier of your log. Use the details to be more specific and add some context. The details field can either be a String or a Map, so that you can associate multiple key-values for additional context.

Events can be renamed on the FollowAnalytics platform

The name that you give to your event here can be overridden in the FollowAnalytics platform. For more information, reach out to your Customer Success Manager or message support.

For example, you can log the display of a view by writing the following:

FollowAnalytics.logEvent("Product Page", "Product #42");
FollowAnalytics.logError("Error log", "This is an error!");

Use a Map for the details field, the value of which must contain a String type.

HashMap<String, String> detailsMap = new HashMap<String, String>();
detailsMap.put("product_id", "42");
detailsMap.put("product_category", "Jeans");
FollowAnalytics.logEvent("Add product to cart", detailsMap);

Parameters over 60Kb will be refused by the method. Running in debug mode, it will return returning NO and write a message in the console.

Logging from a web view

This feature is limited to Android 4.2 and above

Logging from web view is a feature that is only activated for Android versions above 4.2 "Jelly Bean" (API Version >= 17) in order to prevent a security flaw in Google's Android SDK. You may find more details here in the documentation provided by Android.

If your app contains web views, you can also tag events and errors from within your HTML/JS code. FollowAnalytics SDK Android has a class called FAWebView which allows the integration in three steps.

  1. Declare the FAWebView element into your <layout>.xml. For instance:

            &lt;LinearLayout xmlns:android=""
                android:layout_height="match_parent" &gt;
  2. In the corresponding activity which uses the <layout>.xml layout, retrieve the ID associated with FAWebView element integrated in the layout. For instance:

            FAWebView faWebView = (FAWebView) view.findViewById(;
  3. Inject the HTML file/page to the FAWebView element by using the loadUrl method.


Notice that log events, user attributes and InApp properties can be used in the HTML file by using the following methods:

Make sure to test if FollowAnalytics object exists with if (typeof FollowAnalytics !== 'undefined'). This way, you can reuse the exact same HTML code for your mobile web site without impact.

User ID and attributes

This section covers the integration of a user ID and customer attributes. The SDK allows you to set values for attributes FollowAnalytics has predefined as well as custom attributes which you can make yourself.

You don't need a user ID to set attributes

Attributes are tied to the device when no user ID is provided. If a user ID is set, a profile is created server side and can be shared across apps.

In both cases, attributes can be used in segments and campaigns to target users.

User ID

What is a user ID?

If users can sign in somewhere in your app, you can specify their identifier to the SDK. Unique to each user, this identifier can be an e-mail address, internal client identifier, phone number, or anything else that ties your customers to you. This is what we call the user ID.

A user ID enables you to relate any event to a specific user across several devices. It is also an essential component for transactional campaigns. A common user ID enables you connect to a CRM or other external systems.

To register the user ID, use:

FollowAnalytics.setUserId(String UserId);

To remove the user identifier (for example in case of a sign out) use the following method:


Predefined attributes

Predefined attributes are attributes that will be attached to default fields on your user profiles. FollowAnalytics SDK has the following properties for predefined attributes:

setFirstName(String firstName);
setLastName(String lastName);
setEmail(String email);
setBirthDate(Date birthDate);
setGender(Gender gender);
setCountry(String country);
setCity(String city);
setRegion(String region);

For example, to set user Joe's city to "Paris", you would proceed as follows:


Custom attributes

In addition to predefined attributes, you can add your own custom attributes to your code.

Always double check your custom attribute types

When a value for an unknown attribute is received by the server, the attribute is declared with the type of that first value.

If you change the type of an attribute in the SDK, values might be refused server-side. Ensure the attribute types match. This could be done by comparing with the ones you have in the profile data section of the product.

Set a custom attribute

To set your custom attributes, you can use methods that are adapted for each type: setInt, setString,setBoolean, setDate, setDateTime and setDouble.

For example, to set the user's job:

FollowAnalytics.UserAttributes.setString("occupation", "Taxi driver");
Delete a custom attribute value

You can delete the value of an attribute using its key. For example, to delete the user's job:

Set of attributes

You can add or remove an item to or from a set of attributes.

To add an item:


To remove an item:

FollowAnalytics.UserAttributes.removeFromSet("fruits","lemon"); // Removes "lemon" from set of fruits.

And to clear a set:

FollowAnalytics.UserAttributes.clearSet("fruits");  // Removes all the items from the set.

For further information, refer to the SDK header file.

Opt-Out Analytics

Deprecated methods since version 5.4.0

Be sure to update the next methods : setCollectLogsAuthorization(boolean authorized), setCollectLocationLogsAuthorization(boolean authorized), canCollectLocationLogs(), canCollectLogs() with the appropriated methods available and explained below.

What is Opt-out analytics?

The SDK can be configured to no longer track user information. This is what we call to opt out of analytics.

Once opted-out, no new data is collected, nor is it stored in the application. New session are not generated at launch and nothing is sent back to the server. This data includes the following:

  • tagged elements such as events, errors
  • new user identification and attributes
  • crash reports

When a user is opted-out of analytics, campaigns will continue to work with the following limitations:

  • No Contextual campaigns - as they depend on log tracking
  • No Transactional campaigns - as they depend on the user ID
  • No Dynamic campaigns - as they depend on users entering a segment
  • Campaigns filters will depend on old data (before the user opted-out)

All data collected before the user has opted-out is preserved within FollowAnalytics servers. This means that a user having opted-out will still receive campaigns based on data acquired before opting out (previous campaigns, existing segments, etc). The opt-in state is persisted between app starts (unless storage of the app is emptied).


FollowAnalytics SDK is opt-in by default at the initialization. However you can configure it to opt-out before the initialization by adding and overriding the method getOptInAnalyticsDefault() and by changing the value of this method in the configuration class.

Create the configuration class

In order to proceed you need to create the Advanced Configuration class.

For instance :

import com.followanalytics.FollowAnalytics;

public class Configuration extends FollowAnalytics.Configuration {
        public boolean getOptInAnalyticsDefault() {
                return false; //&lt;- this method returns false which is equivalent to opt-out

The customized configuration class is only used for the default value of the opt-in state. However the opt-in runtime has the final say about logs that are collected or not.

At runtime, FollowAnalytics SDK uses the value returned by FollowAnalytics.getOptInAnalytics() to decide log collection. The default value of this property is explained in the previous subsection. Once changed, the new value is saved into persistent memory and remains the same at every launch of the application.

If you want to change the value of the opt-in state at runtime, use the setOptInAnalytics method:

FollowAnalytics.setOptInAnalytics(boolean state); // &lt;- state set to true is equal to opt-in, but state set to false is equal to opt-out

In order to retrieve the value of the opt-in state that FollowAnalytics SDK is handling at runtime, use the getOptInAnalytics method:



To request the data collected with FollowAnalytics SDK, use the following method :


To delete the data that has been collected with FollowAnalytics SDK, use the following method :



Campaign basics

What we mean by campaigns are the messages that you send to your user from the FollowAnalytics platform. Currently, FollowAnalytics enables you to send two types of campaigns: push notifications and in-app campaigns. Push notifications allow you to send messages to your user's home screen, whereas an in-app is a messages that is displayed in the app while the user is actively using it.

In this section, we cover all you need for your app to receive the campaigns sent from the FollowAnalytics platform, and how you can add the features the fully take advantage of the SDK's capabilities.

Before you start, be sure that the SDK is properly initialized. This includes registration for push notifications, which is covered in the "Integration" section above.

Customize push notifications

Notification icon customization

The SDK will use your applauncher icon as default notification icon. You could change this by adding a ic_fa_notification.png file in your drawable folders. If you wish to have a custom background color on your notifications, you can add a value to your color.xml: <color name="ic_fa_notification_color">#ff0000</color>. Be sure to follow Google's guidelines for notification icons on Android.

If you need to customize your push notifications, you have to extend this class FollowAnalytics.DefaultMessageHandler and override the method onPushMessageNotificationBuilding(...) to the class that you created.

For example:

public class FollowPushHandler extends FollowAnalytics.DefaultMessageHandler {

    public void onPushMessageNotificationBuilding(Context context, NotificationCompat.Builder notificationBuilder,  FollowAnalytics.Message message) {
     //customize the notification

Then, add to the manifest file the path of the class that extends FollowAnalytics.DefaultMessageHandler as a meta-data tag under the application tag. For example:

&lt;meta-data android:name=“com.followanalytics.deeplinking.handler” android:value=“the_full_path_of_your_message_FollowPushHandler”/&gt;

Now that everything is set up, customize your notification under the method onPushMessageNotificationBuilding.

An example of adding buttons to the notification is available below.

    public void onPushMessageNotificationBuilding(Context context, NotificationCompat.Builder notificationBuilder, FollowAnalytics.Message message) {
    super.onPushMessageNotificationBuilding(context, notificationBuilder, message);
    if (message.getCategory().equalsIgnoreCase("social")) {
        PendingIntent pendingIntentActions1 = null; //your pendingIntent when user click on button like
        PendingIntent pendingIntentActions2 =  null; //your pendingIntent when user click on button comment
        NotificationCompat.Action action1 = new NotificationCompat.Action.Builder(android.R.drawable.ic_menu_send, "Like", pendingIntentActions1).build();
        NotificationCompat.Action action2 = new NotificationCompat.Action.Builder(android.R.drawable.ic_menu_help, "comment", pendingIntentActions2).build();

Deep-linking: URL, Parameters

Push notification campaigns created through FollowAnalytics allow to deep link to content in an app (not limited to your own). You can use either an App Link, or use a customized key-value parameters that are forwarded to your code.

SDK behavior

The SDK manages automatically App-Links. Be sure to follow the google documentation for internal deep-links of the application.

The SDK introduced the possibility to use direct App Links like twitter://messages, which will send you to the corresponding screen inside of the Twitter application.

You're able to access the functionality by enabling the Deep Linking on the platform, when creating a campaign. There you'll find the field App Link that expects you to enter these type of URL schemas. It can either be an URL schema to an external app or for your own application.

Customizing deep-linking parameters

Customizing deep-linking parameters

Google provides it's own recommendations for implementing deep-linking which you can find here. If you wish to implement it differently, please read the content below.

In FollowAnalytics campaigns through the platform, you can specify deep-linking parameters, e.g. in your push messages or for in-app button actions.

These parameters are given to the developer's code by the SDK. It is then up to the developer to implement the deep-links in the app (specific path of screens, format of the arguments, etc.).

To obtain these parameters, extend the FollowAnalytics.DefaultMessageHandler class, like in this example:

public class CustomMessageHandler extends FollowAnalytics.DefaultMessageHandler {

     * This method is executed with no App Links. Only key-values were set.
     public void onPushMessageClicked(Context context, Map&lt;String, String&gt; data) {
         String value1 = data.get("a_custom_param_key");
         if(value1 !=null &amp;&amp; data.get(value1).equals("a_custom_param_value_expected")){
             //Execute the code for the customized deep-link with a key : "a_custom_param_key" and a value : "a_custom_param_value_expected"
             Intent intent = new Intent(context, SpecificActivity.class);
            //Let the SDK handle the notification
            super.onPushMessageClicked(context, data);


     * This method is executed when an App Link was, at least, set (through the clients portal).
         public void onPushMessageClicked(Context context, String url, Map&lt;String, String&gt; data) {
            //Do something with the url

     public void onInAppMessageClicked(Context context, String buttonText, Map&lt;String, String&gt; data) {
         // Same as the above method, but from a in-app message!

If you chose to define a custom MessageHandler, you must declare it in your app manifest as meta-data:

    &lt;meta-data android:name="com.followanalytics.deeplinking.handler" android:value="fully_qualified_identifier_to_your_class"/&gt;

Through the key value format, FollowAnalytics supports both standardized deep-linking (by defining the key you'll always use to give the path), and more direct parameter passing for simpler use cases integrations.

Regular deep-link is usually implemented using a Router, that will handle the URL called on the app and translate it into the display of the right page, with the right content.

Custom Handling of Rich Campaigns

What are Rich Campaigns?

Among the layouts available on the FollowAnalytics platform, you can choose "Custom web page" and "templates". These layouts are called Rich Campaigns. Our SDK provides a default display for Rich campaigns, but you can replace them with your one of your own.

Rich campaigns can be handled directly by the app code, instead of being shown automatically by the SDK. The behavior is defined when creating the campaign, using the "automatically display content" switch.

For campaigns where the content is not handled by FollowAnalytics, you will need to extend and declare it in your AndroidManifest.xml. You'll need to use an intent-filter on BROADCAST_RICH_CAMPAIGNS_ACTION. For example:

&lt;receiver android:name=".RichCampaignDataReceiver" &gt;
        &lt;action android:name="%YOUR_APP_PACKAGE_NAME%.BROADCAST_RICH_CAMPAIGNS_ACTION" /&gt;

Where %YOUR_APP_PACKAGE_NAME% is your app package name.

The method onRichCampaignDataReceived must be overridden. Rich campaign parameters are provided as method arguments:

Pausing and resuming in-app campaigns

What is pausing and resuming an in-app campaign?

Pausing campaigns are used to prevent in-app from being displayed on certain screens and views of your application. You may pause a screen of the app when it is too important, or is part of a process that is too important to be interrupted by an in-app (i.e a payment screen in the process of the user making a purchase).

When the screen is safe to display an in-app, you resume in-app campaigns. Any campaign that was supposed to be displayed when the mechanism wakes paused is stacked. It will be shown as soon as the mechanism is resumed. This way you can send send in-app campaigns without impacting the user experience.

To pause and resume campaigns, add the following methods in you code at the location you wish the pause and resume to take effect:

FollowAnalytics.InApp.pauseCampaignDisplay();  # will pause campaign display
FollowAnalytics.InApp.resumeCampaignDisplay();  # will resume campaign display

Create safe spaces for you in-app messages

Rather than pause everywhere you have an important screen or process, you can pause right at the initialization of the SDK and resume in the areas you think it is safe for in-app messages to be displayed.

Enable campaign archiving

FollowAnalytics SDK allows you to store all campaigns and push notifications received by your application. This makes them available for custom usage, like building an inbox. To enable this feature, add the following line in the app manifest under the tag application.

Data Wallet

What is the Data Wallet?

The Data Wallet is a consent management and data declaration tool that helps you on your way to in compliance with GDPR.

Your Data Wallet puts together with what is called a policy. This policy which is created from the FollowAnalytics platform, is what brings together the legal texts, data categories, recipients and purposes you have determined in your Data Wallet. There could only be one policy at a time. Every time it is updated on the platform, the policy downloaded by the SDK.

All the data in the SDK will be in a JSON format and the developer will need to reorganize them in order to display them. The use of this feature is one of the most advanced for FollowAnalytics. We recommend that the developer working with the Data Wallet should be familiar with the FollowAnalytics and that most features were already installed.


Create the configuration class

The Data Wallet is one of the more advanced features provided by FollowAnalytics. In order to proceed you need to create the Advanced Configuration class.

Data Wallet is disabled by default in FollowAnalytics SDK. In order to activate this function, you need to add and override the method isDataWalletEnabled() by changing the return value in the configuration class.

For instance :

import com.followanalytics.FollowAnalytics;

public class Configuration extends FollowAnalytics.Configuration {
    public boolean isDataWalletEnabled(){
            return true; // &lt;- Datawallet is enabled by returning the value true

Local Policy

FollowAnalytics SDK offers you the possibility to add a default policy file.

When no other policy is yet available, the SDK returns a default empty policy having version 0.0.

Follow these steps below in order to add the policy file in your project:

1 - Create an assets folder in your app project.

2 - Add the policy file in the assets folder (policy file downloaded from the platform).

3 - Add and override the method getDefaultPolicyFilePath(), in the configuration class, by returning the path of the policy file. The path must be a relative path from the assets folder.

For instance :

import com.followanalytics.FollowAnalytics;

public class Configuration extends FollowAnalytics.Configuration {
    public String getDefaultPolicyFilePath(){
        return "FollowAnalytics/Policy.config"; // &lt;- Path of the default policy file

Callback Policy

FollowAnalytics SDK has a callback method that is triggered whenever a significant policy version is retrieved (for instance, going from version 1.8 to 2.4). The method is triggered when the leftmost digit of the version is increased.

Read status

The read status of the policy is always set to false whenever the callback method is triggered. A new major version of the policy has to be accepted again by the users of the app, even if they accepted a previous version.

Add and override the method onDataWalletPolicyChanged() and insert code in order to interact with the newest and significant updated policy in your application.

import com.followanalytics.FollowAnalytics;

public class Configuration extends FollowAnalytics.Configuration {
    public void onDataWalletPolicyChanged(){
        //insert code to interact with your application

Policy methods

Get Policy

To access the latest available policy, call the method getPolicy :


This method returns an object called Policy. Policy allows you to acquire and process the information related to the policy set in the Data Wallet (version, legal texts, data categories, etc).

Policy status

To check the read status of the policy, use the following method :


This method returns a boolean value.

To change the read status of the policy, use the method setIsRead(boolean read) with a boolean value as parameter.

FollowAnalytics.Datawallet.setIsRead(boolean read);

The policy is read when the boolean parameter is true and is not read when it is false.

Advanced Use Cases

Advanced Configuration

Notification channel for Android 8.0 (Oreo)

Since Google has refactored of its "Notification system" for Android 8.0 ("Oreo"), (details here) FollowAnalytics SDK uses default_notification_fa as an id for id for the NotificationChannel object.

In order to customize the behavior of FollowAnalytics SDK, it is possible to change the default configuration.

You can customize Opt-Out analytics and Datawallet.

In order to achieve this, create a class that extends to FollowAnalytics.Configuration and override only the methods that are necessary to change.

import com.followanalytics.FollowAnalytics;

public class Configuration extends FollowAnalytics.Configuration {
    public boolean getOptInAnalyticsDefault() { //&lt;- method added from Configuration section in GDPR chapter
        return false;

Finally, add a meta-data tag under the application tag to your android manifest. The value of android:name must be identical as com.followanalytics.configuration and the value of android:value is the path of the configuration class:


For instance:

    android:value=""/&gt; &lt;!-- &lt;-- this is the path of the Configuration class created--&gt;

Now, FollowAnalytics SDK will start by default with the value associated to the methods overridden in the customized configuration class.

Migrating from GCM to FCM with your own key

Before you begin, you need Firebase installed

Install Firebase Cloud Messaging (FCM) in your project, by following this guide.

FCM and GCM do not coexist

When you choose to migrate from GCM to FCM, the application on the platform will only recognise the new FCM to send push notifications. This means, that since the GCM key will no longer be functional, the users who haven't updated their app with the 6.0 FollowAnalytics SDK will not be able to receive push notifications.

If you want to avoid having issues with your campaigns, you can encourage your users to update their app. You can do this by targeting your users with in-app campaign, with a link to the PlayStore, that they will see at the opening of the app.

  1. Remove any reference to GCM in your build.gradle file.

    dependencies {
      compile ";VERSION&gt;"
  2. Edit your app's manifest file by removing some required permissions and receiver functionality from GCM.

    &lt;uses-permission android:name="android.permission.WAKE_LOCK" /&gt;
    &lt;permission android:name="&lt;PACKAGE_NAME&gt;.permission.C2D_MESSAGE"
                android:protectionLevel="signature" /&gt;
    &lt;uses-permission android:name="&lt;PACKAGE_NAME&gt;.permission.C2D_MESSAGE" /&gt;
        android:permission="" &gt;
            &lt;action android:name="" /&gt;
            &lt;category android:name="&lt;PACKAGE_NAME&gt;" /&gt;
            &lt;action android:name="" /&gt;
            &lt;action android:name="" /&gt;
  3. Migrate the code available in InstanceIDListenerService class to FirebaseMessagingService class.

    public class MyInstanceIDListenerService extends InstanceIDListenerService {
      public void onTokenRefresh() {
          //Code available here
    public class MyFirebaseMessagingService extends FirebaseMessagingService {
        public void onNewToken(String s){
            //Migrate the code here and do not forget to refactor your code

    Do not forget to refactor your code, due to Google API changes

  4. Migrate the code available in GcmListenerService class to FirebaseMessagingService class. Also do not forget to refactor your code, due to Google API changes.

    public class MyGcmListenerService extends GcmListenerService {
      public void onMessageReceived(String from, Bundle data){
          //Code available here
    public class MyFirebaseMessagingService extends FirebaseMessagingService {
        public void onMessageReceived(RemoteMessage remoteMessage) {
            //Migrate the code here and do not forget to refactor your code
            FollowAnalytics.processFirebaseMessage(this, remoteMessage);

    Do not forget to refactor your code, due to Google API changes

  5. Finally, delete InstanceIDListenerService and GcmListenerService class from your project.



If you need to obfuscate and/or shrink your app before Google Play publication, be sure you protect the FollowAnalytics SDK, otherwise logs won't be sent.

Here is the ProGuard configuration:

-keep class com.followanalytics.** { *; }
-keep interface** { *; }