The next major version of FollowAnalytics SDK will remove the support of GCM and instead will use Firebase services.

Minimal setup

In this section, we explain how to get started with FollowAnalytics SDK for Android. 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 ''
  1. 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

This dependency allows some devices to show the count of unread messages as a badge on the app shortcut.


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
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

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. Consider testing push notifications on release mode.

The FollowAnalytics SDK supports push notifications based on Google Cloud Messaging. To ensure notifications cannot be caught by other applications than yours, follow the steps below.

  1. Add the following permissions to your manifest:
<permission android:name="%YOUR_APP_PACKAGE_NAME%.permission.C2D_MESSAGE"
                android:protectionLevel="signature" />
 <uses-permission android:name="%YOUR_APP_PACKAGE_NAME%.permission.C2D_MESSAGE" />
  1. Add the GCM Receiver to your manifest

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.

Notification 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.

Notifications on wearables

Notifications on wearables are enabled by default. Should you need to disable them, you can use the FollowAnalytics.setGcmRegistrationEnabled(true or false) 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.

Limit the bandwidth for sending logs to FollowAnalytics

If your app runs in a context where bandwidth is limited, (for example with wearable devices), you can set a minimum time between the SDK network calls using FollowAnalytics.setGcmRegistrationEnabled(true or false)

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);
<!-- TODO put it back when the public API will be changed
HashMap<String, ?> detailsMap = new HashMap<String, Object>();
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

!!! warning "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:

<LinearLayout xmlns:android=""
    android:layout_height="match_parent" >



  1. 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:

<a onclick="FollowAnalytics.logEvent('My event');">Send event without detail</a>
<a onclick="FollowAnalytics.logEvent('My event', 'My event details');">Send event with detail</a>
<a onclick="FollowAnalytics.logError('fromWebView without detail');">Send error without detail</a>
<a onclick="FollowAnalytics.logError('fromWebView with detail','Error detail');">Send error with detail</a>
- User Attributes:

<div class="button" onclick="FollowAnalytics.UserAttributes.setFirstName('Isaac');">Set first name</div><br>
<div class="button" onclick="FollowAnalytics.UserAttributes.setLastName('Newton');">Set last name</div><br>
<div class="button" onclick="FollowAnalytics.UserAttributes.setEmail('');">Set email</div><br>
<div class="button" onclick="FollowAnalytics.getDeviceId(displayDeviceID);">Get Device ID</div><br>

<div class="button" onclick="FollowAnalytics.InApp.pauseCampaignDisplay();">Pause Campaign</div><br>
<div class="button" onclick="FollowAnalytics.InApp.resumeCampaignDisplay();">Resume Campaign</div><br>
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; //<- 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); // <- 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

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:

<meta-data android:name=“com.followanalytics.deeplinking.handler” android:value=“the_full_path_of_your_message_FollowPushHandler”/>

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<String, String> data) {
         String value1 = data.get("a_custom_param_key");
         if(value1 !=null && 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<String, String> data) {
            //Do something with the url

     public void onInAppMessageClicked(Context context, String buttonText, Map<String, String> 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:

    <meta-data android:name="com.followanalytics.deeplinking.handler" android:value="fully_qualified_identifier_to_your_class"/>

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:

<receiver android:name=".RichCampaignDataReceiver" >

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.

Firebase integration

If you use Firebase to manage your push notifications, FollowAnalytics SDK doesn't handle it with the latest version.

FollowAnalytics SDK and Firebase

The next major version of FollowAnalytics will handle Firebase services.

You can use a Firebase implementation (your own) and GCM implementation (from FollowAnalytics SDK) independently with no communication between FA SDK and FCM services.

Working with multiple GCMs

If you are already using GCM in your application, you will have to check the sender of each notification, as it can now come from different providers (e.g. you and FollowAnalytics).


This tutorial assumes that GCM is already implemented in your application. Skip to the next section f you don't already have a GCM implementation. FollowAnalytics SDK adds the GCM push notification automatically.

Before beginning the implementation, let's summarize the objectives and ideas that the app will do with multiple GCM.

  1. The app must retrieve the token (push notification) independently of any sender ID (multiple sender ID) and send it, optionally, to a server.

  2. The app will be able to receive one or multiple push notifications, and treat them separately.

Manifest application

  1. Remove any GCM Receiver implemented in your project (FollowAnalytics SDK will implement it automatically). For instance :
<receiver android:name=""
        <action android:name="" />
        <category android:name= "com.followanalytics.sdk.azme.integration" />
<!--             -->
  1. Implement a Service that will receive all the push notifications. For instance :
        <action android:name=""/>
<!--             -->
  1. Make sure that GCM permissions are implemented.
<permission android:name="<PACKAGE_NAME>.permission.C2D_MESSAGE" android:protectionLevel="signature" />
<uses-permission android:name="<PACKAGE_NAME>.permission.C2D_MESSAGE"/>
  1. Finally, make sure that you are able to retrieve the token with different providers by declaring the correct Service. For instance, this is a Service that retrieves the token for Azure push notification system:
<service android:name=".azure.MyInstanceIDService" android:exported="false">
        <action android:name=""/>
// This service retrieves the token also

Gradle application

  1. Remove the plugin for GCM if available :
//apply plugin: ''
  1. Remove the dependencies from GCM (FollowAnalytics SDK already adds it).
//implementation ''

Project, Java class implementation

Now that we settled the Manifest and Gradle files, let's implement the classes.

  1. Implement the Service extended to GcmListenerService (declared previously in the manifest). For instance :
public class OtherExternalPushService extends GcmListenerService{
    public static final int NOTIFICATION_ID = 123;
    private NotificationManager mNotificationManager;
    NotificationCompat.Builder mBuilder;

    public OtherExternalPushService() {

    public void onMessageReceived(String from, Bundle data) {
        super.onMessageReceived(from, data);

        //Treat every sender Id that the app might have (for instance, this is a push notification from Azure Microsoft)

            //Do whatever you need to do for this message (parse the message, send to the notification manager, etc...)

            mNotificationManager = (NotificationManager) this.getApplicationContext().getSystemService(Context.NOTIFICATION_SERVICE);

            if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                //----------CREATE CHANNEL
                // The id of the channel.
                String id = "my_channel_01";
                // The user-visible name of the channel.
                CharSequence name = "Azure Channel";
                // The user-visible description of the channel.«
                String description = "This is a description";
                int importance = NotificationManager.IMPORTANCE_HIGH;
                NotificationChannel mChannel = new NotificationChannel(id, name, importance);
                // Configure the notification channel.
                // Sets the notification light color for notifications posted to this
                // channel, if the device supports this feature.
                mChannel.setVibrationPattern(new long[]{100, 200, 300, 400, 500, 400, 300, 200, 400});
                //----------END CREATE CHANNEL

                mBuilder =
                        new NotificationCompat.Builder(this.getApplicationContext(), id)
                                .setContentTitle("Notification Hub Demo Azure")
                                .setStyle(new NotificationCompat.BigTextStyle()
                mBuilder =
                        new NotificationCompat.Builder(this.getApplicationContext())
                                .setContentTitle("Notification Hub Demo Azure")
                                .setStyle(new NotificationCompat.BigTextStyle()
            mNotificationManager.notify(NOTIFICATION_ID+(new Random().nextInt()),;
            // As there is no more sender id to treat, this is a FollowAnalytics message, let's inject the message to FollowAnalytics SDK, by using the following function

            Log.d("OtherExternalPushServi","Sender id :"+from);
            FollowAnalytics.processFollowAnalyticsPush(this, data.getString(PushManager.BUNDLE_KEY_MESSAGE));

Now that everything is implemented, you can use/test push notifications with multiple GCM.

An example of a project with multiple GCM is available here : Github

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; // <- 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"; // <- 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

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() { //<- 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=""/> <!--this is the path of the Configuration class created-->

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



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** { *; }