clevertap-react-native 0.5.0 → 0.7.0

package/android/src/main/java/com/clevertap/react/CleverTapModule.java

@@ -1,19 +1,16 @@
 package com.clevertap.react;
 
-import android.annotation.SuppressLint;
 import android.location.Location;
 import android.net.Uri;
 import android.os.Build.VERSION;
 import android.os.Build.VERSION_CODES;
 import android.os.Bundle;
 import android.util.Log;
-import com.clevertap.android.sdk.CTExperimentsListener;
+import androidx.annotation.RequiresApi;
 import com.clevertap.android.sdk.CTFeatureFlagsListener;
 import com.clevertap.android.sdk.CTInboxListener;
-import com.clevertap.android.sdk.CTInboxMessage;
 import com.clevertap.android.sdk.CTInboxStyleConfig;
 import com.clevertap.android.sdk.CleverTapAPI;
-import com.clevertap.android.sdk.EventDetail;
 import com.clevertap.android.sdk.InAppNotificationButtonListener;
 import com.clevertap.android.sdk.InAppNotificationListener;
 import com.clevertap.android.sdk.InboxMessageButtonListener;
@@ -21,7 +18,10 @@ import com.clevertap.android.sdk.SyncListener;
 import com.clevertap.android.sdk.UTMDetail;
 import com.clevertap.android.sdk.displayunits.DisplayUnitListener;
 import com.clevertap.android.sdk.displayunits.model.CleverTapDisplayUnit;
+import com.clevertap.android.sdk.events.EventDetail;
 import com.clevertap.android.sdk.featureFlags.CTFeatureFlagsController;
+import com.clevertap.android.sdk.inbox.CTInboxMessage;
+import com.clevertap.android.sdk.interfaces.OnInitCleverTapIDListener;
 import com.clevertap.android.sdk.product_config.CTProductConfigController;
 import com.clevertap.android.sdk.product_config.CTProductConfigListener;
 import com.clevertap.android.sdk.pushnotification.CTPushNotificationListener;
@@ -50,15 +50,42 @@ import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
+@SuppressWarnings({"unused", "RedundantSuppression"})
 public class CleverTapModule extends ReactContextBaseJavaModule implements SyncListener,
         InAppNotificationListener, CTInboxListener,
-        CTExperimentsListener, InboxMessageButtonListener,
+        InboxMessageButtonListener,
         InAppNotificationButtonListener, DisplayUnitListener, CTProductConfigListener,
         CTFeatureFlagsListener, CTPushNotificationListener {
 
-    private ReactApplicationContext context;
+    @SuppressWarnings("FieldCanBeLocal")
+    private enum InBoxMessages {
+        ALL(0),
+        UNREAD(1);
 
-    private CleverTapAPI mCleverTap;
+        private final int value;
+
+        InBoxMessages(final int newValue) {
+            value = newValue;
+        }
+
+    }
+
+    private enum ErrorMessages {
+
+        CLEVERTAP_NOT_INITIALIZED("CleverTap not initialized"),
+        PRODUCTCONFIG_NOT_INITIALIZED("Product Config not initialized"),
+        FF_NOT_INITIALIZED("Feature Flags not initialized");
+
+        private final String errorMessage;
+
+        ErrorMessages(String s) {
+            errorMessage = s;
+        }
+
+        public String getErrorMessage() {
+            return errorMessage;
+        }
+    }
 
     private static Uri mlaunchURI;
 
@@ -84,8 +111,6 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
 
     private static final String CLEVERTAP_INBOX_MESSAGES_DID_UPDATE = "CleverTapInboxMessagesDidUpdate";
 
-    private static final String CLEVERTAP_EXPERIMENTS_DID_UPDATE = "CleverTapExperimentsDidUpdate";
-
     private static final String CLEVERTAP_ON_INBOX_BUTTON_CLICK = "CleverTapInboxMessageButtonTapped";
 
     private static final String CLEVERTAP_ON_INAPP_BUTTON_CLICK = "CleverTapInAppNotificationButtonTapped";
@@ -102,157 +127,57 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
 
     private static final String CLEVERTAP_PUSH_NOTIFICATION_CLICKED = "CleverTapPushNotificationClicked";
 
-    private enum InBoxMessages {
-        ALL(0),
-        UNREAD(1);
-
-        private final int value;
-
-        InBoxMessages(final int newValue) {
-            value = newValue;
-        }
-
-    }
-
-    private enum ErrorMessages {
-
-        CLEVERTAP_NOT_INITIALIZED("CleverTap not initialized"),
-        PRODUCTCONFIG_NOT_INITIALIZED("Product Config not initialized"),
-        FF_NOT_INITIALIZED("Feature Flags not initialized");
-
-        private final String errorMessage;
-
-        ErrorMessages(String s) {
-            errorMessage = s;
-        }
+    private final ReactApplicationContext context;
 
-        public String getErrorMessage() {
-            return errorMessage;
-        }
-    }
+    private CleverTapAPI mCleverTap;
 
     public static void setInitialUri(final Uri uri) {
         mlaunchURI = uri;
     }
 
-    @Override
-    public String getName() {
-        return REACT_MODULE_NAME;
-    }
-
-    @Override
-    public Map<String, Object> getConstants() {
-        final Map<String, Object> constants = new HashMap<>();
-        constants.put(CLEVERTAP_PROFILE_DID_INITIALIZE, CLEVERTAP_PROFILE_DID_INITIALIZE);
-        constants.put(CLEVERTAP_PROFILE_SYNC, CLEVERTAP_PROFILE_SYNC);
-        constants.put(CLEVERTAP_IN_APP_NOTIFICATION_DISMISSED, CLEVERTAP_IN_APP_NOTIFICATION_DISMISSED);
-        constants.put(FCM, FCM);
-        constants.put(XPS, XPS);
-        constants.put(BPS, BPS);
-        constants.put(HPS, HPS);
-        constants.put(CLEVERTAP_INBOX_DID_INITIALIZE, CLEVERTAP_INBOX_DID_INITIALIZE);
-        constants.put(CLEVERTAP_INBOX_MESSAGES_DID_UPDATE, CLEVERTAP_INBOX_MESSAGES_DID_UPDATE);
-        constants.put(CLEVERTAP_ON_INBOX_BUTTON_CLICK, CLEVERTAP_ON_INBOX_BUTTON_CLICK);
-        constants.put(CLEVERTAP_ON_DISPLAY_UNITS_LOADED, CLEVERTAP_ON_DISPLAY_UNITS_LOADED);
-        constants.put(CLEVERTAP_ON_INAPP_BUTTON_CLICK, CLEVERTAP_ON_INAPP_BUTTON_CLICK);
-        constants.put(CLEVERTAP_FEATURE_FLAGS_DID_UPDATE, CLEVERTAP_FEATURE_FLAGS_DID_UPDATE);
-        constants.put(CLEVERTAP_PRODUCT_CONFIG_DID_INITIALIZE, CLEVERTAP_PRODUCT_CONFIG_DID_INITIALIZE);
-        constants.put(CLEVERTAP_PRODUCT_CONFIG_DID_FETCH, CLEVERTAP_PRODUCT_CONFIG_DID_FETCH);
-        constants.put(CLEVERTAP_PRODUCT_CONFIG_DID_ACTIVATE, CLEVERTAP_PRODUCT_CONFIG_DID_ACTIVATE);
-        constants.put(CLEVERTAP_PUSH_NOTIFICATION_CLICKED, CLEVERTAP_PUSH_NOTIFICATION_CLICKED);
-        return constants;
-    }
-
     public CleverTapModule(ReactApplicationContext reactContext) {
         super(reactContext);
         this.context = reactContext;
         getCleverTapAPI();
     }
 
-    private CleverTapAPI getCleverTapAPI() {
-        if (mCleverTap == null) {
-            CleverTapAPI clevertap = CleverTapAPI.getDefaultInstance(this.context);
-            if (clevertap != null) {
-                clevertap.setCTPushNotificationListener(this);
-                clevertap.setInAppNotificationListener(this);
-                clevertap.setSyncListener(this);
-                clevertap.setCTNotificationInboxListener(this);
-                clevertap.setCTExperimentsListener(this);
-                clevertap.setInboxMessageButtonListener(this);
-                clevertap.setInAppNotificationButtonListener(this);
-                clevertap.setDisplayUnitListener(this);
-                clevertap.setCTProductConfigListener(this);
-                clevertap.setCTFeatureFlagsListener(this);
-                clevertap.setLibrary("React-Native");
-            }
-            mCleverTap = clevertap;
-        }
-
-        return mCleverTap;
-    }
-
-    // launch
-
-    @ReactMethod
-    public void getInitialUrl(Callback callback) {
-        String error = null;
-        String url = null;
-
-        if (mlaunchURI == null) {
-            error = "CleverTap InitialUrl is null";
-        } else {
-            url = mlaunchURI.toString();
-        }
-        callbackWithErrorAndResult(callback, error, url);
-    }
-
-    // push
-
-    @ReactMethod
-    public void registerForPush() {
-        // no-op in Android
-        Log.i(TAG, "CleverTap.registerForPush is a no-op in Android");
-    }
-
     @ReactMethod
-    public void setPushTokenAsString(String token, String type) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null || token == null || type == null) {
+    public void activate() {
+        CTProductConfigController productConfigController = getCtProductConfigController();
+        if (productConfigController == null) {
             return;
         }
+        productConfigController.activate();
+    }
 
-        switch (type) {
-            case FCM:
-                clevertap.pushFcmRegistrationId(token, true);
-                break;
-            case XPS:
-                clevertap.pushXiaomiRegistrationId(token, true);
-                break;
-            case BPS:
-                clevertap.pushBaiduRegistrationId(token, true);
-                break;
-            case HPS:
-                clevertap.pushHuaweiRegistrationId(token, true);
-                break;
-            default:
-                Log.e(TAG, "Unknown push token type " + type);
-                break;
-        }
+    // InAppNotificationListener
+    public boolean beforeShow(Map<String, Object> var1) {
+        return true;
     }
 
-    //UI Editor connection
+    //Custom Push Notification
     @ReactMethod
-    public void setUIEditorConnectionEnabled(boolean enabled) {
+    public void createNotification(ReadableMap extras) {
         CleverTapAPI clevertap = getCleverTapAPI();
         if (clevertap == null) {
             return;
         }
-        CleverTapAPI.setUIEditorConnectionEnabled(enabled);
-        Log.i(TAG, "UI Editor connection enabled - " + enabled);
+        JSONObject extrasJsonObject;
+        try {
+            extrasJsonObject = jsonObjectFromReadableMap(extras);
+            Bundle bundle = new Bundle();
+            for (Iterator<String> entry = extrasJsonObject.keys(); entry.hasNext(); ) {
+                String key = entry.next();
+                String str = extrasJsonObject.optString(key);
+                bundle.putString(key, str);
+            }
+            CleverTapAPI.createNotification(this.context, bundle);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
     }
 
-    //notification channel/group methods for Android O
-
+    @RequiresApi(api = VERSION_CODES.O)
     @ReactMethod
     public void createNotificationChannel(String channelId, String channelName, String channelDescription,
             int importance, boolean showBadge) {
@@ -265,19 +190,18 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
         Log.i(TAG, "Notification Channel " + channelName + " created");
     }
 
+    @RequiresApi(api = VERSION_CODES.O)
     @ReactMethod
-    public void createNotificationChannelWithSound(String channelId, String channelName, String channelDescription,
-            int importance, boolean showBadge, String sound) {
+    public void createNotificationChannelGroup(String groupId, String groupName) {
         CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null || channelId == null || channelName == null || channelDescription == null
-                || sound == null) {
+        if (clevertap == null || groupId == null || groupName == null) {
             return;
         }
-        CleverTapAPI.createNotificationChannel(this.context, channelId, channelName, channelDescription, importance,
-                showBadge, sound);
-        Log.i(TAG, "Notification Channel " + channelName + " with sound file " + sound + " created");
+        CleverTapAPI.createNotificationChannelGroup(this.context, groupId, groupName);
+        Log.i(TAG, "Notification Channel Group " + groupName + " created");
     }
 
+    @RequiresApi(api = VERSION_CODES.O)
     @ReactMethod
     public void createNotificationChannelWithGroupId(String channelId, String channelName, String channelDescription,
             int importance, String groupId, boolean showBadge) {
@@ -291,6 +215,7 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
         Log.i(TAG, "Notification Channel " + channelName + " with Group Id " + groupId + " created");
     }
 
+    @RequiresApi(api = VERSION_CODES.O)
     @ReactMethod
     public void createNotificationChannelWithGroupIdAndSound(String channelId, String channelName,
             String channelDescription, int importance, String groupId, boolean showBadge, String sound) {
@@ -305,16 +230,31 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
                 + " created");
     }
 
+    @RequiresApi(api = VERSION_CODES.O)
     @ReactMethod
-    public void createNotificationChannelGroup(String groupId, String groupName) {
+    public void createNotificationChannelWithSound(String channelId, String channelName, String channelDescription,
+            int importance, boolean showBadge, String sound) {
         CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null || groupId == null || groupName == null) {
+        if (clevertap == null || channelId == null || channelName == null || channelDescription == null
+                || sound == null) {
             return;
         }
-        CleverTapAPI.createNotificationChannelGroup(this.context, groupId, groupName);
-        Log.i(TAG, "Notification Channel Group " + groupName + " created");
+        CleverTapAPI.createNotificationChannel(this.context, channelId, channelName, channelDescription, importance,
+                showBadge, sound);
+        Log.i(TAG, "Notification Channel " + channelName + " with sound file " + sound + " created");
+    }
+
+    @ReactMethod
+    public void deleteInboxMessageForId(String messageId) {
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            cleverTap.deleteInboxMessage(messageId);
+        } else {
+            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
+        }
     }
 
+    @RequiresApi(api = VERSION_CODES.O)
     @ReactMethod
     public void deleteNotificationChannel(String channelId) {
         CleverTapAPI clevertap = getCleverTapAPI();
@@ -325,6 +265,7 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
         Log.i(TAG, "Notification Channel Id " + channelId + " deleted");
     }
 
+    @RequiresApi(api = VERSION_CODES.O)
     @ReactMethod
     public void deleteNotificationChannelGroup(String groupId) {
         CleverTapAPI clevertap = getCleverTapAPI();
@@ -335,189 +276,231 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
         Log.i(TAG, "Notification Channel Group Id " + groupId + " deleted");
     }
 
-    //Custom Push Notification
     @ReactMethod
-    public void createNotification(ReadableMap extras) {
+    public void disablePersonalization() {
         CleverTapAPI clevertap = getCleverTapAPI();
         if (clevertap == null) {
             return;
         }
-        JSONObject extrasJsonObject;
-        try {
-            extrasJsonObject = jsonObjectFromReadableMap(extras);
-            Bundle bundle = new Bundle();
-            for (Iterator<String> entry = extrasJsonObject.keys(); entry.hasNext(); ) {
-                String key = entry.next();
-                String str = extrasJsonObject.optString(key);
-                bundle.putString(key, str);
-            }
-            CleverTapAPI.createNotification(this.context, bundle);
-        } catch (JSONException e) {
-            e.printStackTrace();
-        }
+        clevertap.disablePersonalization();
     }
 
-    //Enables tracking opt out for the currently active user. 
-
     @ReactMethod
-    public void setOptOut(boolean value) {
+    public void enableDeviceNetworkInfoReporting(boolean value) {
         CleverTapAPI clevertap = getCleverTapAPI();
         if (clevertap == null) {
             return;
         }
-        clevertap.setOptOut(value);
+        clevertap.enableDeviceNetworkInfoReporting(value);
     }
 
-    //Sets the SDK to offline mode
     @ReactMethod
-    public void setOffline(boolean value) {
+    public void enablePersonalization() {
         CleverTapAPI clevertap = getCleverTapAPI();
         if (clevertap == null) {
             return;
         }
-        clevertap.setOffline(value);
+        clevertap.enablePersonalization();
     }
 
-    //Enables the reporting of device network-related information, including IP address.  This reporting is disabled by default.
+    //Enables tracking opt out for the currently active user. 
 
     @ReactMethod
-    public void enableDeviceNetworkInfoReporting(boolean value) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-        clevertap.enableDeviceNetworkInfoReporting(value);
-    }
-
-    // Personalization
+    public void eventGetDetail(String eventName, Callback callback) {
+        String error = null;
+        WritableMap result = null;
 
-    @ReactMethod
-    public void enablePersonalization() {
         CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
+        if (clevertap != null) {
+            EventDetail detail = clevertap.getDetails(eventName);
+            result = eventDetailToWritableMap(detail);
+        } else {
+            error = "CleverTap not initialized";
         }
-        clevertap.enablePersonalization();
+        callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void disablePersonalization() {
+    public void eventGetFirstTime(String eventName, Callback callback) {
+        String error = null;
+        int result = -1;
+
         CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
+        if (clevertap != null) {
+            result = clevertap.getFirstTime(eventName);
+        } else {
+            error = "CleverTap not initialized";
         }
-        clevertap.disablePersonalization();
+        callbackWithErrorAndResult(callback, error, result);
     }
 
-    // Event API
+    //Enables the reporting of device network-related information, including IP address.  This reporting is disabled by default.
 
     @ReactMethod
-    public void recordScreenView(String screenName) {
+    public void eventGetLastTime(String eventName, Callback callback) {
+        String error = null;
+        int result = -1;
+
         CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
+        if (clevertap != null) {
+            result = clevertap.getLastTime(eventName);
+        } else {
+            error = "CleverTap not initialized";
         }
-        clevertap.recordScreen(screenName);
+        callbackWithErrorAndResult(callback, error, result);
     }
 
+    // Personalization
+
     @ReactMethod
-    public void recordEvent(String eventName, ReadableMap props) {
+    public void eventGetOccurrences(String eventName, Callback callback) {
+        String error = null;
+        int result = -1;
+
         CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
+        if (clevertap != null) {
+            result = clevertap.getCount(eventName);
+        } else {
+            error = "CleverTap not initialized";
         }
+        callbackWithErrorAndResult(callback, error, result);
+    }
 
-        Map<String, Object> finalProps = eventPropsFromReadableMap(props, Object.class);
+    //Feature Flags Callback
+    @Override
+    public void featureFlagsUpdated() {
+        WritableMap params = Arguments.createMap();
+        sendEvent(CLEVERTAP_FEATURE_FLAGS_DID_UPDATE, params);//passing empty map
+    }
 
-        if (finalProps == null) {
-            clevertap.pushEvent(eventName);
-        } else {
-            clevertap.pushEvent(eventName, finalProps);
+    // Event API
+
+    @ReactMethod
+    public void fetch() {
+        CTProductConfigController productConfigController = getCtProductConfigController();
+        if (productConfigController == null) {
+            return;
         }
+
+        productConfigController.fetch();
     }
 
     @ReactMethod
-    public void recordChargedEvent(ReadableMap details, ReadableArray items) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null || details == null) {
+    public void fetchAndActivate() {
+        CTProductConfigController productConfigController = getCtProductConfigController();
+        if (productConfigController == null) {
             return;
         }
 
-        HashMap<String, Object> finalDetails = eventPropsFromReadableMap(details, Object.class);
-
-        ArrayList<HashMap<String, Object>> finalItems = new ArrayList<>();
+        productConfigController.fetchAndActivate();
+    }
 
-        if (items != null) {
-            for (int i = 0; i < items.size(); i++) {
-                try {
-                    HashMap<String, Object> item = eventPropsFromReadableMap(items.getMap(i), Object.class);
-                    finalItems.add(item);
-                } catch (Throwable t) {
-                    Log.e(TAG, t.getLocalizedMessage());
-                }
-            }
+    @ReactMethod
+    public void fetchWithMinimumFetchIntervalInSeconds(int interval) {
+        CTProductConfigController productConfigController = getCtProductConfigController();
+        if (productConfigController == null) {
+            return;
         }
 
-        try {
-            clevertap.pushChargedEvent(finalDetails, finalItems);
-        } catch (Throwable t) {
-            Log.e(TAG, t.getLocalizedMessage());
-        }
+        productConfigController.fetch(interval);
     }
 
     @ReactMethod
-    public void eventGetFirstTime(String eventName, Callback callback) {
+    public void getAllDisplayUnits(Callback callback) {
         String error = null;
-        int result = -1;
+        WritableArray result = Arguments.createArray();
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getFirstTime(eventName);
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            result = getWritableArrayFromList(cleverTap.getAllDisplayUnits());
         } else {
-            error = "CleverTap not initialized";
+            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
         }
         callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void eventGetLastTime(String eventName, Callback callback) {
+    public void getAllInboxMessages(Callback callback) {
+
+        getInboxMessages(callback, InBoxMessages.ALL);
+    }
+
+    @ReactMethod
+    public void getBoolean(String key, Callback callback) {
         String error = null;
-        int result = -1;
+        Boolean result = null;
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getLastTime(eventName);
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            CTProductConfigController productConfigController = cleverTap.productConfig();
+            if (productConfigController != null) {
+                result = productConfigController.getBoolean(key);
+            } else {
+                error = ErrorMessages.PRODUCTCONFIG_NOT_INITIALIZED.getErrorMessage();
+            }
         } else {
-            error = "CleverTap not initialized";
+            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
         }
         callbackWithErrorAndResult(callback, error, result);
     }
 
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        constants.put(CLEVERTAP_PROFILE_DID_INITIALIZE, CLEVERTAP_PROFILE_DID_INITIALIZE);
+        constants.put(CLEVERTAP_PROFILE_SYNC, CLEVERTAP_PROFILE_SYNC);
+        constants.put(CLEVERTAP_IN_APP_NOTIFICATION_DISMISSED, CLEVERTAP_IN_APP_NOTIFICATION_DISMISSED);
+        constants.put(FCM, FCM);
+        constants.put(XPS, XPS);
+        constants.put(BPS, BPS);
+        constants.put(HPS, HPS);
+        constants.put(CLEVERTAP_INBOX_DID_INITIALIZE, CLEVERTAP_INBOX_DID_INITIALIZE);
+        constants.put(CLEVERTAP_INBOX_MESSAGES_DID_UPDATE, CLEVERTAP_INBOX_MESSAGES_DID_UPDATE);
+        constants.put(CLEVERTAP_ON_INBOX_BUTTON_CLICK, CLEVERTAP_ON_INBOX_BUTTON_CLICK);
+        constants.put(CLEVERTAP_ON_DISPLAY_UNITS_LOADED, CLEVERTAP_ON_DISPLAY_UNITS_LOADED);
+        constants.put(CLEVERTAP_ON_INAPP_BUTTON_CLICK, CLEVERTAP_ON_INAPP_BUTTON_CLICK);
+        constants.put(CLEVERTAP_FEATURE_FLAGS_DID_UPDATE, CLEVERTAP_FEATURE_FLAGS_DID_UPDATE);
+        constants.put(CLEVERTAP_PRODUCT_CONFIG_DID_INITIALIZE, CLEVERTAP_PRODUCT_CONFIG_DID_INITIALIZE);
+        constants.put(CLEVERTAP_PRODUCT_CONFIG_DID_FETCH, CLEVERTAP_PRODUCT_CONFIG_DID_FETCH);
+        constants.put(CLEVERTAP_PRODUCT_CONFIG_DID_ACTIVATE, CLEVERTAP_PRODUCT_CONFIG_DID_ACTIVATE);
+        constants.put(CLEVERTAP_PUSH_NOTIFICATION_CLICKED, CLEVERTAP_PUSH_NOTIFICATION_CLICKED);
+        return constants;
+    }
+
+    // Profile API
+
     @ReactMethod
-    public void eventGetOccurrences(String eventName, Callback callback) {
+    public void getDisplayUnitForId(String unitID, Callback callback) {
         String error = null;
-        int result = -1;
+        String result = null;
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getCount(eventName);
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            CleverTapDisplayUnit displayUnit = cleverTap.getDisplayUnitForId(unitID);
+            if (displayUnit != null && displayUnit.getJsonObject() != null) {
+                result = displayUnit.getJsonObject().toString();
+            }
         } else {
-            error = "CleverTap not initialized";
+            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
         }
         callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void eventGetDetail(String eventName, Callback callback) {
+    public void getDouble(String key, Callback callback) {
         String error = null;
-        WritableMap result = null;
+        Double result = null;
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            EventDetail detail = clevertap.getDetails(eventName);
-            result = eventDetailToWritableMap(detail);
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            CTProductConfigController productConfigController = cleverTap.productConfig();
+            if (productConfigController != null) {
+                result = productConfigController.getDouble(key);
+            } else {
+                error = ErrorMessages.PRODUCTCONFIG_NOT_INITIALIZED.getErrorMessage();
+            }
         } else {
-            error = "CleverTap not initialized";
+            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
         }
         callbackWithErrorAndResult(callback, error, result);
     }
@@ -537,28 +520,34 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
         callbackWithErrorAndResult(callback, error, result);
     }
 
-    // Profile API
-
     @ReactMethod
-    public void setLocation(double latitude, double longitude) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
+    public void getFeatureFlag(String name, Boolean defaultValue, Callback callback) {
+        String error = null;
+        Boolean result = null;
+
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            CTFeatureFlagsController featureFlagsController = cleverTap.featureFlag();
+            if (featureFlagsController != null) {
+                result = featureFlagsController.get(name, defaultValue);
+            } else {
+                error = ErrorMessages.FF_NOT_INITIALIZED.getErrorMessage();
+            }
+        } else {
+            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
         }
-        final Location location = new Location("CleverTapReact");
-        location.setLatitude(latitude);
-        location.setLongitude(longitude);
-        clevertap.setLocation(location);
+        callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void profileGetCleverTapAttributionIdentifier(Callback callback) {
+    public void getInboxMessageCount(Callback callback) {
+
         String error = null;
-        String result = null;
+        int result = -1;
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getCleverTapAttributionIdentifier();
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            result = cleverTap.getInboxMessageCount();
         } else {
             error = "CleverTap not initialized";
         }
@@ -566,224 +555,108 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
     }
 
     @ReactMethod
-    public void profileGetCleverTapID(Callback callback) {
+    public void getInboxMessageForId(String messageId, Callback callback) {
         String error = null;
         String result = null;
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getCleverTapID();
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            CTInboxMessage inboxMessage = cleverTap.getInboxMessageForId(messageId);
+
+            if (inboxMessage != null && inboxMessage.getData() != null) {
+                result = inboxMessage.getData().toString();
+            }
         } else {
-            error = "CleverTap not initialized";
+            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
         }
         callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void onUserLogin(ReadableMap profile) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
+    public void getInboxMessageUnreadCount(Callback callback) {
+        String error = null;
+        int result = -1;
 
-        Map<String, Object> finalProfile = profileFromReadableMap(profile);
-        clevertap.onUserLogin(finalProfile);
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            result = cleverTap.getInboxMessageUnreadCount();
+        } else {
+            error = "CleverTap not initialized";
+        }
+        callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void profileSet(ReadableMap profile) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-
-        Map<String, Object> finalProfile = profileFromReadableMap(profile);
-        clevertap.pushProfile(finalProfile);
-    }
-
-    @ReactMethod
-    public void profileSetGraphUser(ReadableMap profile) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
+    public void getInitialUrl(Callback callback) {
+        String error = null;
+        String url = null;
 
-        try {
-            JSONObject finalProfile = jsonObjectFromReadableMap(profile);
-            clevertap.pushFacebookUser(finalProfile);
-        } catch (Throwable t) {
-            Log.e(TAG, t.getLocalizedMessage());
+        if (mlaunchURI == null) {
+            error = "CleverTap InitialUrl is null";
+        } else {
+            url = mlaunchURI.toString();
         }
+        callbackWithErrorAndResult(callback, error, url);
     }
 
     @ReactMethod
-    @SuppressWarnings("unchecked")
-    public void profileGetProperty(String propertyName, Callback callback) {
+    public void getLastFetchTimeStampInMillis(Callback callback) {
         String error = null;
-        Object result = null;
+        String result = null;
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            Object value = clevertap.getProperty(propertyName);
-            // Handle JSONArray for multi-values, otherwise everything should be primitive or String
-            if (value instanceof JSONArray) {
-                JSONArray valueArray = (JSONArray) value;
-                WritableArray writableArray = Arguments.createArray();
-                for (int i = 0; i < valueArray.length(); i++) {
-                    try {
-                        writableArray.pushString(valueArray.get(i).toString());
-                    } catch (JSONException e) {
-                        //no-op
-                    }
-                }
-                result = writableArray;
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            CTProductConfigController productConfigController = cleverTap.productConfig();
+            if (productConfigController != null) {
+                result = String.valueOf(productConfigController.getLastFetchTimeStampInMillis());
             } else {
-                result = value;
+                error = ErrorMessages.PRODUCTCONFIG_NOT_INITIALIZED.getErrorMessage();
             }
-
         } else {
-            error = "CleverTap not initialized";
+            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
         }
         callbackWithErrorAndResult(callback, error, result);
     }
 
-    @ReactMethod
-    public void profileRemoveValueForKey(String key) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-        clevertap.removeValueForKey(key);
-    }
-
-    @ReactMethod
-    public void profileSetMultiValues(ReadableArray values, String key) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-        ArrayList<String> finalValues = arrayListStringFromReadableArray(values);
-        clevertap.setMultiValuesForKey(key, finalValues);
-    }
-
-    @ReactMethod
-    public void profileAddMultiValue(String value, String key) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-        clevertap.addMultiValueForKey(key, value);
-    }
-
-    @ReactMethod
-    public void profileAddMultiValues(ReadableArray values, String key) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-        ArrayList<String> finalValues = arrayListStringFromReadableArray(values);
-        clevertap.addMultiValuesForKey(key, finalValues);
-    }
-
-    @ReactMethod
-    public void profileRemoveMultiValue(String value, String key) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-        clevertap.removeMultiValueForKey(key, value);
-    }
-
-    @ReactMethod
-    public void profileRemoveMultiValues(ReadableArray values, String key) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-        ArrayList<String> finalValues = arrayListStringFromReadableArray(values);
-        clevertap.removeMultiValuesForKey(key, finalValues);
-    }
-
-    // Session API
-
-    @ReactMethod
-    public void pushInstallReferrer(String source, String medium, String campaign) {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return;
-        }
-        clevertap.pushInstallReferrer(source, medium, campaign);
-    }
-
-    @ReactMethod
-    public void sessionGetTimeElapsed(Callback callback) {
-        String error = null;
-        int result = -1;
-
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getTimeElapsed();
-        } else {
-            error = "CleverTap not initialized";
-        }
-        callbackWithErrorAndResult(callback, error, result);
+    @Override
+    public String getName() {
+        return REACT_MODULE_NAME;
     }
 
     @ReactMethod
-    public void sessionGetTotalVisits(Callback callback) {
+    public void getString(String key, Callback callback) {
         String error = null;
-        int result = -1;
+        String result = null;
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getTotalVisits();
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            CTProductConfigController productConfigController = cleverTap.productConfig();
+            if (productConfigController != null) {
+                result = productConfigController.getString(key);
+            } else {
+                error = ErrorMessages.PRODUCTCONFIG_NOT_INITIALIZED.getErrorMessage();
+            }
         } else {
-            error = "CleverTap not initialized";
+            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
         }
         callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void sessionGetScreenCount(Callback callback) {
-        String error = null;
-        int result = -1;
+    public void getUnreadInboxMessages(Callback callback) {
 
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getScreenCount();
-        } else {
-            error = "CleverTap not initialized";
-        }
-        callbackWithErrorAndResult(callback, error, result);
+        getInboxMessages(callback, InBoxMessages.UNREAD);
     }
 
-    @ReactMethod
-    public void sessionGetPreviousVisitTime(Callback callback) {
-        String error = null;
-        int result = -1;
-
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            result = clevertap.getPreviousVisitTime();
-        } else {
-            error = "CleverTap not initialized";
-        }
-        callbackWithErrorAndResult(callback, error, result);
+    //Inbox Callbacks
+    public void inboxDidInitialize() {
+        WritableMap params = Arguments.createMap();
+        sendEvent(CLEVERTAP_INBOX_DID_INITIALIZE, params);//passing empty map
     }
 
-    @ReactMethod
-    public void sessionGetUTMDetails(Callback callback) {
-        String error = null;
-        WritableMap result = null;
-
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap != null) {
-            UTMDetail details = clevertap.getUTMDetails();
-            result = utmDetailsToWritableMap(details);
-        } else {
-            error = "CleverTap not initialized";
-        }
-        callbackWithErrorAndResult(callback, error, result);
+    public void inboxMessagesDidUpdate() {
+        WritableMap params = Arguments.createMap();
+        sendEvent(CLEVERTAP_INBOX_MESSAGES_DID_UPDATE, params); //passing empty map
     }
 
     //App Inbox methods
@@ -797,580 +670,478 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
     }
 
     @ReactMethod
-    public void showInbox(ReadableMap styleConfig) {
-        CTInboxStyleConfig inboxStyleConfig = styleConfigFromReadableMap(styleConfig);
+    public void markReadInboxMessageForId(String messageId) {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            cleverTap.showAppInbox(inboxStyleConfig);
+            cleverTap.markReadInboxMessage(messageId);
+        } else {
+            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
         }
     }
 
-    @ReactMethod
-    public void getInboxMessageCount(Callback callback) {
+    @Override
+    public void onActivated() {
+        WritableMap params = Arguments.createMap();
+        sendEvent(CLEVERTAP_PRODUCT_CONFIG_DID_ACTIVATE, params);//passing empty map
+    }
 
-        String error = null;
-        int result = -1;
+    public void onDismissed(Map<String, Object> var1, @Nullable Map<String, Object> var2) {
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getInboxMessageCount();
-        } else {
-            error = "CleverTap not initialized";
-        }
-        callbackWithErrorAndResult(callback, error, result);
-    }
+        WritableMap extrasParams = getWritableMapFromMap(var1);
+        WritableMap actionExtrasParams = getWritableMapFromMap(var2);
 
-    @ReactMethod
-    public void getInboxMessageUnreadCount(Callback callback) {
-        String error = null;
-        int result = -1;
+        WritableMap params = Arguments.createMap();
+        params.putMap("extras", extrasParams);
+        params.putMap("actionExtras", actionExtrasParams);
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getInboxMessageUnreadCount();
-        } else {
-            error = "CleverTap not initialized";
-        }
-        callbackWithErrorAndResult(callback, error, result);
+        sendEvent(CLEVERTAP_IN_APP_NOTIFICATION_DISMISSED, params);
     }
 
-    @ReactMethod
-    public void getAllInboxMessages(Callback callback) {
+    //Native Display callback
+    public void onDisplayUnitsLoaded(ArrayList<CleverTapDisplayUnit> units) {
+        WritableMap params = Arguments.createMap();
+        params.putArray("displayUnits", getWritableArrayFromList(units));
+        sendEvent(CLEVERTAP_ON_DISPLAY_UNITS_LOADED, params);
+    }
 
-        getInboxMessages(callback, InBoxMessages.ALL);
+    @Override
+    public void onFetched() {
+        WritableMap params = Arguments.createMap();
+        sendEvent(CLEVERTAP_PRODUCT_CONFIG_DID_FETCH, params);//passing empty map
     }
 
-    @ReactMethod
-    public void getUnreadInboxMessages(Callback callback) {
+    //Native Display methods
 
-        getInboxMessages(callback, InBoxMessages.UNREAD);
+    //InApp Notification callback
+    public void onInAppButtonClick(HashMap<String, String> hashMap) {
+        sendEvent(CLEVERTAP_ON_INAPP_BUTTON_CLICK, getWritableMapFromMap(hashMap));
     }
 
-    @ReactMethod
-    public void getInboxMessageForId(String messageId, Callback callback) {
-        String error = null;
-        String result = null;
+    public void onInboxButtonClick(HashMap<String, String> payload) {
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            CTInboxMessage inboxMessage = cleverTap.getInboxMessageForId(messageId);
+        sendEvent(CLEVERTAP_ON_INBOX_BUTTON_CLICK, getWritableMapFromMap(payload));
 
-            if (inboxMessage != null && inboxMessage.getData() != null) {
-                result = inboxMessage.getData().toString();
-            }
-        } else {
-            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
-        }
-        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @ReactMethod
-    public void deleteInboxMessageForId(String messageId) {
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.deleteInboxMessage(messageId);
-        } else {
-            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
-        }
+    //Product Config Callback
+    @Override
+    public void onInit() {
+        WritableMap params = Arguments.createMap();
+        sendEvent(CLEVERTAP_PRODUCT_CONFIG_DID_INITIALIZE, params);//passing empty map
+    }
+
+    //Push Notification Clicked callback
+    @Override
+    public void onNotificationClickedPayloadReceived(HashMap<String, Object> payload) {
+        sendEvent(CLEVERTAP_PUSH_NOTIFICATION_CLICKED, getWritableMapFromMap(payload));
     }
 
     @ReactMethod
-    public void markReadInboxMessageForId(String messageId) {
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.markReadInboxMessage(messageId);
-        } else {
-            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
+    public void onUserLogin(ReadableMap profile) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
+            return;
         }
+
+        Map<String, Object> finalProfile = profileFromReadableMap(profile);
+        clevertap.onUserLogin(finalProfile);
     }
 
     @ReactMethod
-    public void pushInboxNotificationViewedEventForId(String messageId) {
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.pushInboxNotificationViewedEvent(messageId);
-        } else {
-            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
+    public void profileAddMultiValue(String value, String key) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
+            return;
         }
+        clevertap.addMultiValueForKey(key, value);
     }
 
     @ReactMethod
-    public void pushInboxNotificationClickedEventForId(String messageId) {
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.pushInboxNotificationClickedEvent(messageId);
-        } else {
-            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
+    public void profileAddMultiValues(ReadableArray values, String key) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
+            return;
         }
+        ArrayList<String> finalValues = arrayListStringFromReadableArray(values);
+        clevertap.addMultiValuesForKey(key, finalValues);
     }
 
-    private void getInboxMessages(Callback callback, InBoxMessages type) {
-        String error = null;
-        ArrayList<CTInboxMessage> inboxMessages = new ArrayList<>();
-        WritableArray result = Arguments.createArray();
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
+    // SyncListener
+    @SuppressWarnings("rawtypes")
+    public void profileDataUpdated(JSONObject updates) {
+        if (updates == null) {
+            return;
+        }
 
-            if (type == InBoxMessages.ALL) {
-                inboxMessages = cleverTap.getAllInboxMessages();
-            } else if (type == InBoxMessages.UNREAD) {
-                inboxMessages = cleverTap.getUnreadInboxMessages();
-            }
+        WritableMap updateParams = Arguments.createMap();
+        Iterator keys = updates.keys();
+        while (keys.hasNext()) {
+            String key = keys.next().toString();
+            try {
+                JSONArray arr = updates.getJSONArray(key);
+                WritableArray writableArray = Arguments.createArray();
+                for (int n = 0; n < arr.length(); n++) {
+                    JSONObject object = arr.getJSONObject(n);
+                    writableArray.pushString(object.toString());
+                }
+                updateParams.putArray(key, writableArray);
 
-            for (CTInboxMessage message : inboxMessages) {
-                if (message != null && message.getData() != null) {
-                    result.pushString(message.getData().toString());
+            } catch (Throwable t) {
+                try {
+                    Object value = updates.get(key);
+                    updateParams.putString(key, value.toString());
+                } catch (Throwable t1) {
+                    Log.e(TAG, t1.getLocalizedMessage());
                 }
             }
-        } else {
-            error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, result);
+
+        WritableMap params = Arguments.createMap();
+        params.putMap("updates", updateParams);
+        sendEvent(CLEVERTAP_PROFILE_SYNC, params);
     }
 
-    //Native Display methods
+    public void profileDidInitialize(String CleverTapID) {
+        if (CleverTapID == null) {
+            return;
+        }
+        WritableMap params = Arguments.createMap();
+        params.putString("CleverTapID", CleverTapID);
+        sendEvent(CLEVERTAP_PROFILE_DID_INITIALIZE, params);
+    }
 
     @ReactMethod
-    public void getAllDisplayUnits(Callback callback) {
+    public void profileGetCleverTapAttributionIdentifier(Callback callback) {
         String error = null;
-        WritableArray result = Arguments.createArray();
+        String result = null;
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = getWritableArrayFromList(cleverTap.getAllDisplayUnits());
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            result = clevertap.getCleverTapAttributionIdentifier();
         } else {
-            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
+            error = "CleverTap not initialized";
         }
         callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void getDisplayUnitForId(String unitID, Callback callback) {
+    public void profileGetCleverTapID(Callback callback) {
         String error = null;
         String result = null;
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            CleverTapDisplayUnit displayUnit = cleverTap.getDisplayUnitForId(unitID);
-            if (displayUnit != null && displayUnit.getJsonObject() != null) {
-                result = displayUnit.getJsonObject().toString();
-            }
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            result = clevertap.getCleverTapID();
         } else {
-            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
+            error = "CleverTap not initialized";
         }
         callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void pushDisplayUnitViewedEventForID(String unitID) {
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.pushDisplayUnitViewedEventForID(unitID);
-        } else {
-            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
-        }
-    }
+    public void getCleverTapID(final Callback callback) {
+        final CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            clevertap.getCleverTapID(new OnInitCleverTapIDListener() {
+                @Override
+                public void onInitCleverTapID(final String cleverTapID) {
+                    // Callback on main thread
+                    callbackWithErrorAndResult(callback, null, cleverTapID);
+                }
 
-    @ReactMethod
-    public void pushDisplayUnitClickedEventForID(String unitID) {
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.pushDisplayUnitClickedEventForID(unitID);
+            });
         } else {
-            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
+            String error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
+            callbackWithErrorAndResult(callback, error, null);
         }
     }
 
-
-    //Dynamic Variables Methods
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerBooleanVariable(String name) {
-        if (!checkKitkatVersion("registerBooleanVariable"))
-            return;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-                cleverTap.registerBooleanVariable(name);
-        } else {
-            Log.e(TAG, "CleverTap not initialized");
-        }
-    }
+    public void profileGetProperty(String propertyName, Callback callback) {
+        String error = null;
+        Object result = null;
 
-    @SuppressLint("NewApi")
-    @ReactMethod
-    public void registerDoubleVariable(String name) {
-        if (!checkKitkatVersion("registerDoubleVariable"))
-            return;
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            Object value = clevertap.getProperty(propertyName);
+            // Handle JSONArray for multi-values, otherwise everything should be primitive or String
+            if (value instanceof JSONArray) {
+                JSONArray valueArray = (JSONArray) value;
+                WritableArray writableArray = Arguments.createArray();
+                for (int i = 0; i < valueArray.length(); i++) {
+                    try {
+                        writableArray.pushString(valueArray.get(i).toString());
+                    } catch (JSONException e) {
+                        //no-op
+                    }
+                }
+                result = writableArray;
+            } else {
+                result = value;
+            }
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.registerDoubleVariable(name);
         } else {
-            Log.e(TAG, "CleverTap not initialized");
+            error = "CleverTap not initialized";
         }
+        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerIntegerVariable(String name) {
-        if (!checkKitkatVersion("registerIntegerVariable"))
+    public void profileRemoveMultiValue(String value, String key) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.registerIntegerVariable(name);
-        } else {
-            Log.e(TAG, "CleverTap not initialized");
         }
+        clevertap.removeMultiValueForKey(key, value);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerStringVariable(String name) {
-        if (!checkKitkatVersion("registerStringVariable"))
+    public void profileRemoveMultiValues(ReadableArray values, String key) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.registerStringVariable(name);
-        } else {
-            Log.e(TAG, "CleverTap not initialized");
         }
+        ArrayList<String> finalValues = arrayListStringFromReadableArray(values);
+        clevertap.removeMultiValuesForKey(key, finalValues);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerListOfBooleanVariable(String name) {
-        if (!checkKitkatVersion("registerListOfBooleanVariable"))
+    public void profileRemoveValueForKey(String key) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.registerListOfBooleanVariable(name);
-        } else {
-            Log.e(TAG, "CleverTap not initialized");
         }
+        clevertap.removeValueForKey(key);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerListOfDoubleVariable(String name) {
-        if (!checkKitkatVersion("registerListOfDoubleVariable"))
+    public void profileSet(ReadableMap profile) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.registerListOfDoubleVariable(name);
-        } else {
-            Log.e(TAG, "CleverTap not initialized");
         }
+
+        Map<String, Object> finalProfile = profileFromReadableMap(profile);
+        clevertap.pushProfile(finalProfile);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerListOfIntegerVariable(String name) {
-        if (!checkKitkatVersion("registerListOfIntegerVariable"))
+    public void profileSetMultiValues(ReadableArray values, String key) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.registerListOfIntegerVariable(name);
-        } else {
-            Log.e(TAG, "CleverTap not initialized");
         }
+        ArrayList<String> finalValues = arrayListStringFromReadableArray(values);
+        clevertap.setMultiValuesForKey(key, finalValues);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerListOfStringVariable(String name) {
-        if (!checkKitkatVersion("registerListOfStringVariable"))
-            return;
-
+    public void pushDisplayUnitClickedEventForID(String unitID) {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            cleverTap.registerListOfStringVariable(name);
+            cleverTap.pushDisplayUnitClickedEventForID(unitID);
         } else {
-            Log.e(TAG, "CleverTap not initialized");
+            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
         }
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerMapOfBooleanVariable(String name) {
-        if (!checkKitkatVersion("registerMapOfBooleanVariable"))
-            return;
-
+    public void pushDisplayUnitViewedEventForID(String unitID) {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            cleverTap.registerMapOfBooleanVariable(name);
+            cleverTap.pushDisplayUnitViewedEventForID(unitID);
         } else {
-            Log.e(TAG, "CleverTap not initialized");
+            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
         }
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerMapOfDoubleVariable(String name) {
-        if (!checkKitkatVersion("registerMapOfDoubleVariable"))
-            return;
-
+    public void pushInboxNotificationClickedEventForId(String messageId) {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            cleverTap.registerMapOfDoubleVariable(name);
+            cleverTap.pushInboxNotificationClickedEvent(messageId);
         } else {
-            Log.e(TAG, "CleverTap not initialized");
+            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
         }
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerMapOfIntegerVariable(String name) {
-        if (!checkKitkatVersion("registerMapOfIntegerVariable"))
-            return;
-
+    public void pushInboxNotificationViewedEventForId(String messageId) {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            cleverTap.registerMapOfIntegerVariable(name);
+            cleverTap.pushInboxNotificationViewedEvent(messageId);
         } else {
-            Log.e(TAG, "CleverTap not initialized");
+            Log.e(TAG, ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage());
         }
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void registerMapOfStringVariable(String name) {
-        if (!checkKitkatVersion("registerMapOfStringVariable"))
+    public void pushInstallReferrer(String source, String medium, String campaign) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            cleverTap.registerMapOfStringVariable(name);
-        } else {
-            Log.e(TAG, "CleverTap not initialized");
         }
+        clevertap.pushInstallReferrer(source, medium, campaign);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void getBooleanVariable(String name, Boolean defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getBooleanVariable"))
+    public void recordChargedEvent(ReadableMap details, ReadableArray items) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null || details == null) {
             return;
-
-        String error = null;
-        Boolean result = null;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getBooleanVariable(name, defaultValue);
-        } else {
-            error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, result);
-    }
 
-    @SuppressLint("NewApi")
-    @ReactMethod
-    public void getDoubleVariable(String name, Double defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getDoubleVariable"))
-            return;
+        HashMap<String, Object> finalDetails = eventPropsFromReadableMap(details, Object.class);
 
-        String error = null;
-        Double result = null;
+        ArrayList<HashMap<String, Object>> finalItems = new ArrayList<>();
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getDoubleVariable(name, defaultValue);
-        } else {
-            error = "CleverTap not initialized";
+        if (items != null) {
+            for (int i = 0; i < items.size(); i++) {
+                try {
+                    HashMap<String, Object> item = eventPropsFromReadableMap(items.getMap(i), Object.class);
+                    finalItems.add(item);
+                } catch (Throwable t) {
+                    Log.e(TAG, t.getLocalizedMessage());
+                }
+            }
         }
-        callbackWithErrorAndResult(callback, error, result);
-    }
-
-    @SuppressLint("NewApi")
-    @ReactMethod
-    public void getIntegerVariable(String name, int defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getIntegerVariable"))
-            return;
-
-        String error = null;
-        int result = -1;
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getIntegerVariable(name, defaultValue);
-        } else {
-            error = "CleverTap not initialized";
+        try {
+            clevertap.pushChargedEvent(finalDetails, finalItems);
+        } catch (Throwable t) {
+            Log.e(TAG, t.getLocalizedMessage());
         }
-        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void getStringVariable(String name, String defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getStringVariable"))
+    public void recordEvent(String eventName, ReadableMap props) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
+        }
 
-        String error = null;
-        String result = null;
+        Map<String, Object> finalProps = eventPropsFromReadableMap(props, Object.class);
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getStringVariable(name, defaultValue);
+        if (finalProps == null) {
+            clevertap.pushEvent(eventName);
         } else {
-            error = "CleverTap not initialized";
+            clevertap.pushEvent(eventName, finalProps);
         }
-        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void getListOfBooleanVariable(String name, ReadableArray defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getListOfBooleanVariable"))
+    public void recordScreenView(String screenName) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
-
-        String error = null;
-        List<Boolean> result = null;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap
-                    .getListOfBooleanVariable(name, arrayListFromReadableArray(defaultValue, Boolean.class));
-        } else {
-            error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, writableArrayFromArrayList(result, Boolean.class));
+        try {
+            clevertap.recordScreen(screenName);
+        } catch (NullPointerException npe) {
+            Log.e(TAG, "Something went wrong in native SDK!");
+            npe.printStackTrace();
+        }
     }
 
-    @SuppressLint("NewApi")
-    @ReactMethod
-    public void getListOfDoubleVariable(String name, ReadableArray defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getListOfDoubleVariable"))
-            return;
-
-        String error = null;
-        List<Double> result = null;
+    // Product Config methods
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getListOfDoubleVariable(name, arrayListFromReadableArray(defaultValue, Double.class));
-        } else {
-            error = "CleverTap not initialized";
-        }
-        callbackWithErrorAndResult(callback, error, writableArrayFromArrayList(result, Double.class));
+    @ReactMethod
+    public void registerForPush() {
+        // no-op in Android
+        Log.i(TAG, "CleverTap.registerForPush is a no-op in Android");
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void getListOfIntegerVariable(String name, ReadableArray defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getListOfIntegerVariable"))
+    public void reset() {
+        CTProductConfigController productConfigController = getCtProductConfigController();
+        if (productConfigController == null) {
             return;
-
-        String error = null;
-        List<Integer> result = null;
-
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap
-                    .getListOfIntegerVariable(name, arrayListFromReadableArray(defaultValue, Integer.class));
-        } else {
-            error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, writableArrayFromArrayList(result, Integer.class));
+
+        productConfigController.reset();
     }
 
-    @SuppressLint("NewApi")
-    @ReactMethod
-    public void getListOfStringVariable(String name, ReadableArray defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getListOfStringVariable"))
-            return;
+    // Feature Flag methods
 
+    @ReactMethod
+    public void sessionGetPreviousVisitTime(Callback callback) {
         String error = null;
-        List<String> result = null;
+        int result = -1;
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getListOfStringVariable(name, arrayListFromReadableArray(defaultValue, String.class));
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            result = clevertap.getPreviousVisitTime();
         } else {
             error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, writableArrayFromArrayList(result, String.class));
+        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @SuppressLint("NewApi")
-    @ReactMethod
-    public void getMapOfBooleanVariable(String name, ReadableMap defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getMapOfBooleanVariable"))
-            return;
+    // Developer Options
 
+    @ReactMethod
+    public void sessionGetScreenCount(Callback callback) {
         String error = null;
-        Map<String, Boolean> result = null;
+        int result = -1;
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getMapOfBooleanVariable(name, eventPropsFromReadableMap(defaultValue, Boolean.class));
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            result = clevertap.getScreenCount();
         } else {
             error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, writableMapFromMap(result, Boolean.class));
+        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @SuppressLint("NewApi")
-    @ReactMethod
-    public void getMapOfDoubleVariable(String name, ReadableMap defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getMapOfDoubleVariable"))
-            return;
+    // private helpers etc
 
+    @ReactMethod
+    public void sessionGetTimeElapsed(Callback callback) {
         String error = null;
-        Map<String, Double> result = null;
+        int result = -1;
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getMapOfDoubleVariable(name, eventPropsFromReadableMap(defaultValue, Double.class));
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            result = clevertap.getTimeElapsed();
         } else {
             error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, writableMapFromMap(result, Double.class));
+        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void getMapOfIntegerVariable(String name, ReadableMap defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getMapOfIntegerVariable"))
-            return;
-
+    public void sessionGetTotalVisits(Callback callback) {
         String error = null;
-        Map<String, Integer> result = null;
+        int result = -1;
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getMapOfIntegerVariable(name, eventPropsFromReadableMap(defaultValue, Integer.class));
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            result = clevertap.getTotalVisits();
         } else {
             error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, writableMapFromMap(result, Integer.class));
+        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @SuppressLint("NewApi")
     @ReactMethod
-    public void getMapOfStringVariable(String name, ReadableMap defaultValue, Callback callback) {
-        if (!checkKitkatVersion("getMapOfStringVariable"))
-            return;
-
+    public void sessionGetUTMDetails(Callback callback) {
         String error = null;
-        Map<String, String> result = null;
+        WritableMap result = null;
 
-        CleverTapAPI cleverTap = getCleverTapAPI();
-        if (cleverTap != null) {
-            result = cleverTap.getMapOfStringVariable(name, eventPropsFromReadableMap(defaultValue, String.class));
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap != null) {
+            UTMDetail details = clevertap.getUTMDetails();
+            result = utmDetailsToWritableMap(details);
         } else {
             error = "CleverTap not initialized";
         }
-        callbackWithErrorAndResult(callback, error, writableMapFromMap(result, String.class));
+        callbackWithErrorAndResult(callback, error, result);
     }
 
-    // Product Config methods
+    @ReactMethod
+    public void setDebugLevel(int level) {
+        CleverTapAPI.setDebugLevel(level);
+    }
 
     @ReactMethod
     public void setDefaultsMap(ReadableMap map) {
@@ -1384,180 +1155,125 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
     }
 
     @ReactMethod
-    public void fetch() {
-        CTProductConfigController productConfigController = getCtProductConfigController();
-        if (productConfigController == null) {
+    public void setLocation(double latitude, double longitude) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
         }
-
-        productConfigController.fetch();
+        final Location location = new Location("CleverTapReact");
+        location.setLatitude(latitude);
+        location.setLongitude(longitude);
+        clevertap.setLocation(location);
     }
 
     @ReactMethod
-    public void fetchWithMinimumFetchIntervalInSeconds(int interval) {
+    public void setMinimumFetchIntervalInSeconds(int interval) {
         CTProductConfigController productConfigController = getCtProductConfigController();
         if (productConfigController == null) {
             return;
         }
 
-        productConfigController.fetch(interval);
+        productConfigController.setMinimumFetchIntervalInSeconds(interval);
     }
 
+    //Sets the SDK to offline mode
     @ReactMethod
-    public void activate() {
-        CTProductConfigController productConfigController = getCtProductConfigController();
-        if (productConfigController == null) {
+    public void setOffline(boolean value) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
         }
-
-        productConfigController.activate();
+        clevertap.setOffline(value);
     }
 
     @ReactMethod
-    public void fetchAndActivate() {
-        CTProductConfigController productConfigController = getCtProductConfigController();
-        if (productConfigController == null) {
+    public void setOptOut(boolean value) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
             return;
         }
-
-        productConfigController.fetchAndActivate();
+        clevertap.setOptOut(value);
     }
 
     @ReactMethod
-    public void setMinimumFetchIntervalInSeconds(int interval) {
-        CTProductConfigController productConfigController = getCtProductConfigController();
-        if (productConfigController == null) {
+    public void setPushTokenAsString(String token, String type) {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null || token == null || type == null) {
             return;
         }
 
-        productConfigController.setMinimumFetchIntervalInSeconds(interval);
-    }
-
-    @ReactMethod
-    public void reset() {
-        CTProductConfigController productConfigController = getCtProductConfigController();
-        if (productConfigController == null) {
-            return;
+        switch (type) {
+            case FCM:
+                clevertap.pushFcmRegistrationId(token, true);
+                break;
+            case XPS:
+                clevertap.pushXiaomiRegistrationId(token, true);
+                break;
+            case BPS:
+                clevertap.pushBaiduRegistrationId(token, true);
+                break;
+            case HPS:
+                clevertap.pushHuaweiRegistrationId(token, true);
+                break;
+            default:
+                Log.e(TAG, "Unknown push token type " + type);
+                break;
         }
-
-        productConfigController.reset();
     }
 
     @ReactMethod
-    public void getString(String key, Callback callback) {
-        String error = null;
-        String result = null;
-
+    public void showInbox(ReadableMap styleConfig) {
+        CTInboxStyleConfig inboxStyleConfig = styleConfigFromReadableMap(styleConfig);
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            CTProductConfigController productConfigController = cleverTap.productConfig();
-            if (productConfigController != null) {
-                result = productConfigController.getString(key);
-            } else {
-                error = ErrorMessages.PRODUCTCONFIG_NOT_INITIALIZED.getErrorMessage();
-            }
-        } else {
-            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
+            cleverTap.showAppInbox(inboxStyleConfig);
         }
-        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @ReactMethod
-    public void getBoolean(String key, Callback callback) {
-        String error = null;
-        Boolean result = null;
+    // Increment/Decrement Operator
 
+    @ReactMethod
+    public void profileIncrementValueForKey(Double value,String key) {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            CTProductConfigController productConfigController = cleverTap.productConfig();
-            if (productConfigController != null) {
-                result = productConfigController.getBoolean(key);
-            } else {
-                error = ErrorMessages.PRODUCTCONFIG_NOT_INITIALIZED.getErrorMessage();
-            }
-        } else {
-            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
+            cleverTap.incrementValue(key, value);
         }
-        callbackWithErrorAndResult(callback, error, result);
     }
 
     @ReactMethod
-    public void getDouble(String key, Callback callback) {
-        String error = null;
-        Double result = null;
-
+    public void profileDecrementValueForKey(Double value,String key) {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            CTProductConfigController productConfigController = cleverTap.productConfig();
-            if (productConfigController != null) {
-                result = productConfigController.getDouble(key);
-            } else {
-                error = ErrorMessages.PRODUCTCONFIG_NOT_INITIALIZED.getErrorMessage();
-            }
-        } else {
-            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
+            cleverTap.decrementValue(key, value);
         }
-        callbackWithErrorAndResult(callback, error, result);
     }
 
-    @ReactMethod
-    public void getLastFetchTimeStampInMillis(Callback callback) {
-        String error = null;
-        String result = null;
+    // InApp Controls
 
+    @ReactMethod
+    public void suspendInAppNotifications() {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            CTProductConfigController productConfigController = cleverTap.productConfig();
-            if (productConfigController != null) {
-                result = String.valueOf(productConfigController.getLastFetchTimeStampInMillis());
-            } else {
-                error = ErrorMessages.PRODUCTCONFIG_NOT_INITIALIZED.getErrorMessage();
-            }
-        } else {
-            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
-        }
-        callbackWithErrorAndResult(callback, error, result);
-    }
-
-    private CTProductConfigController getCtProductConfigController() {
-        CleverTapAPI clevertap = getCleverTapAPI();
-        if (clevertap == null) {
-            return null;
+            cleverTap.suspendInAppNotifications();
         }
+    }
 
-        return clevertap.productConfig();
-    }
-
-    // Feature Flag methods
-
-    @ReactMethod
-    public void getFeatureFlag(String name, Boolean defaultValue, Callback callback) {
-        String error = null;
-        Boolean result = null;
-
+    @ReactMethod
+    public void discardInAppNotifications() {
         CleverTapAPI cleverTap = getCleverTapAPI();
         if (cleverTap != null) {
-            CTFeatureFlagsController featureFlagsController = cleverTap.featureFlag();
-            if (featureFlagsController != null) {
-                result = featureFlagsController.get(name, defaultValue);
-            } else {
-                error = ErrorMessages.FF_NOT_INITIALIZED.getErrorMessage();
-            }
-        } else {
-            error = ErrorMessages.CLEVERTAP_NOT_INITIALIZED.getErrorMessage();
+            cleverTap.discardInAppNotifications();
         }
-        callbackWithErrorAndResult(callback, error, result);
     }
 
-    // Developer Options
-
     @ReactMethod
-    public void setDebugLevel(int level) {
-        CleverTapAPI.setDebugLevel(level);
+    public void resumeInAppNotifications() {
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+            cleverTap.resumeInAppNotifications();
+        }
     }
 
-    // private helpers etc
-
     /**
      * result must be primitive, String or com.facebook.react.bridge.WritableArray/WritableMap
      * see https://github.com/facebook/react-native/issues/3101#issuecomment-143954448
@@ -1574,142 +1290,17 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
         }
     }
 
-    private void sendEvent(String eventName, @Nullable Object params) {
-        try {
-            this.context
-                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                    .emit(eventName, params);
-        } catch (Throwable t) {
-            Log.e(TAG, t.getLocalizedMessage());
-        }
-    }
-
-    private static JSONObject jsonObjectFromReadableMap(ReadableMap readableMap) throws JSONException {
-        JSONObject object = new JSONObject();
-        ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
-        while (iterator.hasNextKey()) {
-            String key = iterator.nextKey();
-            switch (readableMap.getType(key)) {
-                case Null:
-                    object.put(key, JSONObject.NULL);
-                    break;
-                case Boolean:
-                    object.put(key, readableMap.getBoolean(key));
-                    break;
-                case Number:
-                    object.put(key, readableMap.getDouble(key));
-                    break;
-                case String:
-                    object.put(key, readableMap.getString(key));
-                    break;
-                case Map:
-                    object.put(key, jsonObjectFromReadableMap(readableMap.getMap(key)));
-                    break;
-                case Array:
-                    object.put(key, jsonArrayFromReadableArray(readableMap.getArray(key)));
-                    break;
-            }
-        }
-        return object;
-    }
-
-    private static JSONArray jsonArrayFromReadableArray(ReadableArray readableArray) throws JSONException {
-        JSONArray array = new JSONArray();
-        for (int i = 0; i < readableArray.size(); i++) {
-            switch (readableArray.getType(i)) {
-                case Null:
-                    break;
-                case Boolean:
-                    array.put(readableArray.getBoolean(i));
-                    break;
-                case Number:
-                    array.put(readableArray.getDouble(i));
-                    break;
-                case String:
-                    array.put(readableArray.getString(i));
-                    break;
-                case Map:
-                    array.put(jsonObjectFromReadableMap(readableArray.getMap(i)));
-                    break;
-                case Array:
-                    array.put(jsonArrayFromReadableArray(readableArray.getArray(i)));
-                    break;
-            }
-        }
-        return array;
-    }
-
-    private static ArrayList<String> arrayListStringFromReadableArray(ReadableArray readableArray) {
-        ArrayList<String> array = new ArrayList<>();
-        for (int i = 0; i < readableArray.size(); i++) {
-            switch (readableArray.getType(i)) {
-                case Null:
-                    break;
-                case Boolean:
-                    array.add(String.valueOf(readableArray.getBoolean(i)));
-                    break;
-                case Number:
-                    array.add(String.valueOf(readableArray.getDouble(i)));
-                    break;
-                case String:
-                    array.add(readableArray.getString(i));
-                    break;
-            }
-        }
-        return array;
-    }
-
-    private static <T> ArrayList<T> arrayListFromReadableArray(ReadableArray readableArray, Class<T> tClass) {
-        ArrayList<T> array = new ArrayList<>();
-        for (int i = 0; i < readableArray.size(); i++) {
-            switch (readableArray.getType(i)) {
-                case Null:
-                    break;
-                case Boolean:
-                    array.add(tClass.cast(readableArray.getBoolean(i)));
-                    break;
-                case Number:
-                    try {
-                        array.add(tClass.cast(readableArray.getDouble(i)));
-                    } catch (Throwable t) {
-                        try {
-                            array.add(tClass.cast(readableArray.getInt(i)));
-                        } catch (Throwable t1) {
-                            Log.e(TAG, "Unhandled ReadableType.Number from ReadableArray");
-                        }
-                    }
-                    break;
-                case String:
-                    array.add(tClass.cast(readableArray.getString(i)));
-                    break;
-            }
-        }
-        return array;
-    }
+    // Listeners
 
-    private static <T> WritableArray writableArrayFromArrayList(List<T> list, Class<T> tClass) {
-        WritableArray writableArray = Arguments.createArray();
-        if (list != null) {
-            for (Object item : list) {
-                switch (tClass.getSimpleName()) {
-                    case "Boolean":
-                        writableArray.pushBoolean((Boolean) item);
-                        break;
-                    case "Double":
-                        writableArray.pushDouble((Double) item);
-                        break;
-                    case "Integer":
-                        writableArray.pushInt((Integer) item);
-                        break;
-                    case "String":
-                        writableArray.pushString((String) item);
-                        break;
-                }
-            }
+    private boolean checkKitkatVersion(String methodName) {
+        if (VERSION.SDK_INT < VERSION_CODES.KITKAT) {
+            Log.e(TAG, "Call requires API level 19 (current min is " + VERSION.SDK_INT + "):" + methodName);
+            return false;
         }
-        return writableArray;
+        return true;
     }
 
+    @SuppressWarnings("SameParameterValue")
     private <T> HashMap<String, T> eventPropsFromReadableMap(ReadableMap propsMap, Class<T> tClass) {
         if (propsMap == null) {
             return null;
@@ -1748,6 +1339,95 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
         return props;
     }
 
+    private CleverTapAPI getCleverTapAPI() {
+        if (mCleverTap == null) {
+            CleverTapAPI clevertap = CleverTapAPI.getDefaultInstance(this.context);
+            if (clevertap != null) {
+                clevertap.setCTPushNotificationListener(this);
+                clevertap.setInAppNotificationListener(this);
+                clevertap.setSyncListener(this);
+                clevertap.setCTNotificationInboxListener(this);
+                clevertap.setInboxMessageButtonListener(this);
+                clevertap.setInAppNotificationButtonListener(this);
+                clevertap.setDisplayUnitListener(this);
+                clevertap.setCTProductConfigListener(this);
+                clevertap.setCTFeatureFlagsListener(this);
+                clevertap.setLibrary("React-Native");
+            }
+            mCleverTap = clevertap;
+        }
+
+        return mCleverTap;
+    }
+
+    private CTProductConfigController getCtProductConfigController() {
+        CleverTapAPI clevertap = getCleverTapAPI();
+        if (clevertap == null) {
+            return null;
+        }
+
+        return clevertap.productConfig();
+    }
+
+    private void getInboxMessages(Callback callback, InBoxMessages type) {
+        String error = null;
+        ArrayList<CTInboxMessage> inboxMessages = new ArrayList<>();
+        WritableArray result = Arguments.createArray();
+
+        CleverTapAPI cleverTap = getCleverTapAPI();
+        if (cleverTap != null) {
+
+            if (type == InBoxMessages.ALL) {
+                inboxMessages = cleverTap.getAllInboxMessages();
+            } else if (type == InBoxMessages.UNREAD) {
+                inboxMessages = cleverTap.getUnreadInboxMessages();
+            }
+
+            for (CTInboxMessage message : inboxMessages) {
+                if (message != null && message.getData() != null) {
+                    result.pushString(message.getData().toString());
+                }
+            }
+        } else {
+            error = "CleverTap not initialized";
+        }
+        callbackWithErrorAndResult(callback, error, result);
+    }
+
+    private WritableArray getWritableArrayFromList(List<CleverTapDisplayUnit> list) {
+        WritableArray writableArray = Arguments.createArray();
+        if (list != null) {
+            for (CleverTapDisplayUnit item : list) {
+                if (item != null && item.getJsonObject() != null) {
+                    writableArray.pushString(item.getJsonObject().toString());
+                }
+            }
+        }
+        return writableArray;
+    }
+
+    @SuppressWarnings({"TypeParameterExplicitlyExtendsObject", "rawtypes"})
+    private WritableMap getWritableMapFromMap(Map<String, ? extends Object> var1) {
+        JSONObject extras = var1 != null ? new JSONObject(var1) : new JSONObject();
+        WritableMap extrasParams = Arguments.createMap();
+        Iterator extrasKeys = extras.keys();
+        while (extrasKeys.hasNext()) {
+            String key = null;
+            String value = null;
+            try {
+                key = extrasKeys.next().toString();
+                value = extras.get(key).toString();
+            } catch (Throwable t) {
+                Log.e(TAG, t.getLocalizedMessage());
+            }
+
+            if (key != null && value != null) {
+                extrasParams.putString(key, value);
+            }
+        }
+        return extrasParams;
+    }
+
     private HashMap<String, Object> profileFromReadableMap(ReadableMap profileMap) {
         if (profileMap == null) {
             return null;
@@ -1799,40 +1479,16 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
             }
         }
         return profile;
-    }
-
-    private static WritableMap eventDetailToWritableMap(EventDetail details) {
-        WritableMap ret = Arguments.createMap();
-
-        if (details != null) {
-            ret.putString("name", details.getName());
-            ret.putInt("firstTime", details.getFirstTime());
-            ret.putInt("lastTime", details.getLastTime());
-            ret.putInt("count", details.getCount());
-        }
-        return ret;
-    }
-
-    private static WritableMap utmDetailsToWritableMap(UTMDetail details) {
-        WritableMap ret = Arguments.createMap();
-
-        if (details != null) {
-            ret.putString("campaign", details.getCampaign());
-            ret.putString("source", details.getSource());
-            ret.putString("medium", details.getMedium());
-        }
-        return ret;
-    }
-
-    private static WritableMap eventHistoryToWritableMap(Map<String, EventDetail> history) {
-        WritableMap ret = Arguments.createMap();
-
-        if (history != null) {
-            for (String key : history.keySet()) {
-                ret.putMap(key, eventDetailToWritableMap(history.get(key)));
-            }
+    }
+
+    private void sendEvent(String eventName, @Nullable Object params) {
+        try {
+            this.context
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(eventName, params);
+        } catch (Throwable t) {
+            Log.e(TAG, t.getLocalizedMessage());
         }
-        return ret;
     }
 
     private CTInboxStyleConfig styleConfigFromReadableMap(ReadableMap styleConfig) {
@@ -1909,204 +1565,112 @@ public class CleverTapModule extends ReactContextBaseJavaModule implements SyncL
         return ctInboxStyleConfig;
     }
 
-    // Listeners
-
-    // InAppNotificationListener
-    public boolean beforeShow(Map<String, Object> var1) {
-        return true;
-    }
-
-    public void onDismissed(Map<String, Object> var1, @Nullable Map<String, Object> var2) {
-
-        WritableMap extrasParams = getWritableMapFromMap(var1);
-        WritableMap actionExtrasParams = getWritableMapFromMap(var2);
-
-        WritableMap params = Arguments.createMap();
-        params.putMap("extras", extrasParams);
-        params.putMap("actionExtras", actionExtrasParams);
-
-        sendEvent(CLEVERTAP_IN_APP_NOTIFICATION_DISMISSED, params);
-    }
-
-    private WritableMap getWritableMapFromMap(Map<String, ? extends Object> var1) {
-        JSONObject extras = var1 != null ? new JSONObject(var1) : new JSONObject();
-        WritableMap extrasParams = Arguments.createMap();
-        Iterator extrasKeys = extras.keys();
-        while (extrasKeys.hasNext()) {
-            String key = null;
-            String value = null;
-            try {
-                key = extrasKeys.next().toString();
-                value = extras.get(key).toString();
-            } catch (Throwable t) {
-                Log.e(TAG, t.getLocalizedMessage());
-            }
-
-            if (key != null && value != null) {
-                extrasParams.putString(key, value);
+    private static ArrayList<String> arrayListStringFromReadableArray(ReadableArray readableArray) {
+        ArrayList<String> array = new ArrayList<>();
+        for (int i = 0; i < readableArray.size(); i++) {
+            switch (readableArray.getType(i)) {
+                case Null:
+                    break;
+                case Boolean:
+                    array.add(String.valueOf(readableArray.getBoolean(i)));
+                    break;
+                case Number:
+                    array.add(String.valueOf(readableArray.getDouble(i)));
+                    break;
+                case String:
+                    array.add(readableArray.getString(i));
+                    break;
             }
         }
-        return extrasParams;
+        return array;
     }
 
-    private <T> WritableMap writableMapFromMap(Map<String, T> var1, Class<T> tClass) {
-        JSONObject extras = var1 != null ? new JSONObject(var1) : new JSONObject();
-        WritableMap extrasParams = Arguments.createMap();
-        Iterator extrasKeys = extras.keys();
-        while (extrasKeys.hasNext()) {
-            String key;
-            try {
-                key = extrasKeys.next().toString();
-
-                switch (tClass.getSimpleName()) {
-                    case "Boolean":
-                        extrasParams.putBoolean(key, extras.getBoolean(key));
-                        break;
-                    case "Double":
-                        extrasParams.putDouble(key, extras.getDouble(key));
-                        break;
-                    case "Integer":
-                        extrasParams.putInt(key, extras.getInt(key));
-                        break;
-                    case "String":
-                        extrasParams.putString(key, extras.getString(key));
-                        break;
-                }
-            } catch (Throwable t) {
-                Log.e(TAG, t.getLocalizedMessage());
-            }
+    private static WritableMap eventDetailToWritableMap(EventDetail details) {
+        WritableMap ret = Arguments.createMap();
 
+        if (details != null) {
+            ret.putString("name", details.getName());
+            ret.putInt("firstTime", details.getFirstTime());
+            ret.putInt("lastTime", details.getLastTime());
+            ret.putInt("count", details.getCount());
         }
-        return extrasParams;
+        return ret;
     }
 
-    private WritableArray getWritableArrayFromList(List<CleverTapDisplayUnit> list) {
-        WritableArray writableArray = Arguments.createArray();
-        if (list != null) {
-            for (CleverTapDisplayUnit item : list) {
-                if (item != null && item.getJsonObject() != null) {
-                    writableArray.pushString(item.getJsonObject().toString());
-                }
+    private static WritableMap eventHistoryToWritableMap(Map<String, EventDetail> history) {
+        WritableMap ret = Arguments.createMap();
+
+        if (history != null) {
+            for (String key : history.keySet()) {
+                ret.putMap(key, eventDetailToWritableMap(history.get(key)));
             }
         }
-        return writableArray;
+        return ret;
     }
 
-    // SyncListener
-    public void profileDataUpdated(JSONObject updates) {
-        if (updates == null) {
-            return;
-        }
-
-        WritableMap updateParams = Arguments.createMap();
-        Iterator keys = updates.keys();
-        while (keys.hasNext()) {
-            String key = keys.next().toString();
-            try {
-                JSONArray arr = updates.getJSONArray(key);
-                WritableArray writableArray = Arguments.createArray();
-                for (int n = 0; n < arr.length(); n++) {
-                    JSONObject object = arr.getJSONObject(n);
-                    writableArray.pushString(object.toString());
-                }
-                updateParams.putArray(key, writableArray);
-
-            } catch (Throwable t) {
-                try {
-                    Object value = updates.get(key);
-                    updateParams.putString(key, value.toString());
-                } catch (Throwable t1) {
-                    Log.e(TAG, t1.getLocalizedMessage());
-                }
+    private static JSONArray jsonArrayFromReadableArray(ReadableArray readableArray) throws JSONException {
+        JSONArray array = new JSONArray();
+        for (int i = 0; i < readableArray.size(); i++) {
+            switch (readableArray.getType(i)) {
+                case Null:
+                    break;
+                case Boolean:
+                    array.put(readableArray.getBoolean(i));
+                    break;
+                case Number:
+                    array.put(readableArray.getDouble(i));
+                    break;
+                case String:
+                    array.put(readableArray.getString(i));
+                    break;
+                case Map:
+                    array.put(jsonObjectFromReadableMap(readableArray.getMap(i)));
+                    break;
+                case Array:
+                    array.put(jsonArrayFromReadableArray(readableArray.getArray(i)));
+                    break;
             }
         }
-
-        WritableMap params = Arguments.createMap();
-        params.putMap("updates", updateParams);
-        sendEvent(CLEVERTAP_PROFILE_SYNC, params);
+        return array;
     }
 
-    public void profileDidInitialize(String CleverTapID) {
-        if (CleverTapID == null) {
-            return;
+    private static JSONObject jsonObjectFromReadableMap(ReadableMap readableMap) throws JSONException {
+        JSONObject object = new JSONObject();
+        ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            switch (readableMap.getType(key)) {
+                case Null:
+                    object.put(key, JSONObject.NULL);
+                    break;
+                case Boolean:
+                    object.put(key, readableMap.getBoolean(key));
+                    break;
+                case Number:
+                    object.put(key, readableMap.getDouble(key));
+                    break;
+                case String:
+                    object.put(key, readableMap.getString(key));
+                    break;
+                case Map:
+                    object.put(key, jsonObjectFromReadableMap(readableMap.getMap(key)));
+                    break;
+                case Array:
+                    object.put(key, jsonArrayFromReadableArray(readableMap.getArray(key)));
+                    break;
+            }
         }
-        WritableMap params = Arguments.createMap();
-        params.putString("CleverTapID", CleverTapID);
-        sendEvent(CLEVERTAP_PROFILE_DID_INITIALIZE, params);
-    }
-
-    //Inbox Callbacks
-    public void inboxDidInitialize() {
-        WritableMap params = Arguments.createMap();
-        sendEvent(CLEVERTAP_INBOX_DID_INITIALIZE, params);//passing empty map
-    }
-
-    public void inboxMessagesDidUpdate() {
-        WritableMap params = Arguments.createMap();
-        sendEvent(CLEVERTAP_INBOX_MESSAGES_DID_UPDATE, params); //passing empty map
-    }
-
-    public void onInboxButtonClick(HashMap<String, String> payload) {
-
-        sendEvent(CLEVERTAP_ON_INBOX_BUTTON_CLICK, getWritableMapFromMap(payload));
-
-    }
-
-    //InApp Notification callback
-    public void onInAppButtonClick(HashMap<String, String> hashMap) {
-        sendEvent(CLEVERTAP_ON_INAPP_BUTTON_CLICK, getWritableMapFromMap(hashMap));
-    }
-
-    //Native Display callback
-    public void onDisplayUnitsLoaded(ArrayList<CleverTapDisplayUnit> units) {
-        WritableMap params = Arguments.createMap();
-        params.putArray("displayUnits", getWritableArrayFromList(units));
-        sendEvent(CLEVERTAP_ON_DISPLAY_UNITS_LOADED, params);
-    }
-
-    //Experiments Callback
-    public void CTExperimentsUpdated() {
-        WritableMap params = Arguments.createMap();
-        sendEvent(CLEVERTAP_EXPERIMENTS_DID_UPDATE, params);//passing empty map
-    }
-
-    //Feature Flags Callback
-    @Override
-    public void featureFlagsUpdated() {
-        WritableMap params = Arguments.createMap();
-        sendEvent(CLEVERTAP_FEATURE_FLAGS_DID_UPDATE, params);//passing empty map
-    }
-
-    //Product Config Callback
-    @Override
-    public void onInit() {
-        WritableMap params = Arguments.createMap();
-        sendEvent(CLEVERTAP_PRODUCT_CONFIG_DID_INITIALIZE, params);//passing empty map
-    }
-
-    @Override
-    public void onFetched() {
-        WritableMap params = Arguments.createMap();
-        sendEvent(CLEVERTAP_PRODUCT_CONFIG_DID_FETCH, params);//passing empty map
-    }
-
-    @Override
-    public void onActivated() {
-        WritableMap params = Arguments.createMap();
-        sendEvent(CLEVERTAP_PRODUCT_CONFIG_DID_ACTIVATE, params);//passing empty map
+        return object;
     }
 
-    //Push Notification Clicked callback
-    @Override
-    public void onNotificationClickedPayloadReceived(HashMap<String, Object> payload) {
-        sendEvent(CLEVERTAP_PUSH_NOTIFICATION_CLICKED, getWritableMapFromMap(payload));
-    }
+    private static WritableMap utmDetailsToWritableMap(UTMDetail details) {
+        WritableMap ret = Arguments.createMap();
 
-    private boolean checkKitkatVersion(String methodName) {
-        if (VERSION.SDK_INT < VERSION_CODES.KITKAT) {
-            Log.e(TAG, "Call requires API level 19 (current min is " + VERSION.SDK_INT + "):" + methodName);
-            return false;
+        if (details != null) {
+            ret.putString("campaign", details.getCampaign());
+            ret.putString("source", details.getSource());
+            ret.putString("medium", details.getMedium());
         }
-        return true;
+        return ret;
     }
 }