clevertap-react-native 1.0.2 → 1.1.0

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

@@ -1,10 +1,26 @@
 package com.clevertap.react;
 
 import android.util.Log;
+
+import com.clevertap.android.sdk.displayunits.model.CleverTapDisplayUnit;
 import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONArray;
+import org.json.JSONException;
 import org.json.JSONObject;
 
 public class CleverTapUtils {
@@ -33,4 +49,281 @@ public class CleverTapUtils {
         return extrasParams;
     }
 
+    public static WritableArray getWritableArrayFromDisplayUnitList(List<CleverTapDisplayUnit> list) {
+        WritableArray writableArray = Arguments.createArray();
+
+        if (list != null) {
+            for (CleverTapDisplayUnit item : list) {
+                if (item != null && item.getJsonObject() != null) {
+                    WritableMap displayUnitMap = convertObjectToWritableMap(item.getJsonObject());
+                    writableArray.pushMap(displayUnitMap);
+                }
+            }
+        }
+
+        return writableArray;
+    }
+
+    public static WritableMap convertObjectToWritableMap(JSONObject jsonObject) {
+        WritableMap writableMap = Arguments.createMap();
+
+        Iterator<String> keys = jsonObject.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            try {
+                Object value = jsonObject.get(key);
+
+                if (value instanceof String) {
+                    writableMap.putString(key, (String) value);
+                } else if (value instanceof Integer) {
+                    writableMap.putInt(key, (Integer) value);
+                } else if (value instanceof Boolean) {
+                    writableMap.putBoolean(key, (Boolean) value);
+                } else if (value instanceof Float || value instanceof Double) {
+                    writableMap.putDouble(key, Double.parseDouble(value.toString()));
+                } else if (value instanceof JSONObject) {
+                    WritableMap nestedWritableMap = convertObjectToWritableMap((JSONObject) value);
+                    writableMap.putMap(key, nestedWritableMap);
+                } else if (value instanceof JSONArray) {
+                    WritableArray nestedWritableArray = convertArrayToWritableArray((JSONArray) value);
+                    writableMap.putArray(key, nestedWritableArray);
+                }
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return writableMap;
+    }
+
+    private static WritableArray convertArrayToWritableArray(JSONArray jsonArray) {
+        WritableArray writableArray = Arguments.createArray();
+
+        for (int i = 0; i < jsonArray.length(); i++) {
+            try {
+                Object value = jsonArray.get(i);
+
+                if (value instanceof String) {
+                    writableArray.pushString((String) value);
+                } else if (value instanceof Integer) {
+                    writableArray.pushInt((Integer) value);
+                } else if (value instanceof Boolean) {
+                    writableArray.pushBoolean((Boolean) value);
+                } else if (value instanceof Float || value instanceof Double) {
+                    writableArray.pushDouble(Double.parseDouble(value.toString()));
+                } else if (value instanceof JSONObject) {
+                    WritableMap nestedWritableMap = convertObjectToWritableMap((JSONObject) value);
+                    writableArray.pushMap(nestedWritableMap);
+                } else if (value instanceof JSONArray) {
+                    WritableArray nestedWritableArray = convertArrayToWritableArray((JSONArray) value);
+                    writableArray.pushArray(nestedWritableArray);
+                }
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return writableArray;
+    }
+
+    public static class MapUtil {
+
+        public static JSONObject toJSONObject(ReadableMap readableMap) throws JSONException {
+            JSONObject jsonObject = new JSONObject();
+
+            ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+
+            while (iterator.hasNextKey()) {
+                String key = iterator.nextKey();
+                ReadableType type = readableMap.getType(key);
+
+                switch (type) {
+                    case Null:
+                        jsonObject.put(key, null);
+                        break;
+                    case Boolean:
+                        jsonObject.put(key, readableMap.getBoolean(key));
+                        break;
+                    case Number:
+                        jsonObject.put(key, readableMap.getDouble(key));
+                        break;
+                    case String:
+                        jsonObject.put(key, readableMap.getString(key));
+                        break;
+                    case Map:
+                        jsonObject.put(key, MapUtil.toJSONObject(readableMap.getMap(key)));
+                        break;
+                    case Array:
+                        jsonObject.put(key, ArrayUtil.toJSONArray(readableMap.getArray(key)));
+                        break;
+                }
+            }
+
+            return jsonObject;
+        }
+
+
+        public static Map<String, Object> toMap(ReadableMap readableMap) {
+            Map<String, Object> map = new HashMap<>();
+            ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+
+            while (iterator.hasNextKey()) {
+                String key = iterator.nextKey();
+                ReadableType type = readableMap.getType(key);
+
+                switch (type) {
+                    case Null:
+                        map.put(key, null);
+                        break;
+                    case Boolean:
+                        map.put(key, readableMap.getBoolean(key));
+                        break;
+                    case Number:
+                        map.put(key, readableMap.getDouble(key));
+                        break;
+                    case String:
+                        map.put(key, readableMap.getString(key));
+                        break;
+                    case Map:
+                        map.put(key, MapUtil.toMap(readableMap.getMap(key)));
+                        break;
+                    case Array:
+                        map.put(key, ArrayUtil.toArray(readableMap.getArray(key)));
+                        break;
+                }
+            }
+
+            return map;
+        }
+
+        public static WritableMap toWritableMap(Map<String, Object> map) {
+            WritableMap writableMap = Arguments.createMap();
+            Iterator iterator = map.entrySet().iterator();
+
+            while (iterator.hasNext()) {
+                Map.Entry pair = (Map.Entry) iterator.next();
+                writableMap.merge(addValue((String) pair.getKey(), pair.getValue()));
+                iterator.remove();
+            }
+
+            return writableMap;
+        }
+
+        public static WritableMap addValue(String key, Object value) {
+            WritableMap writableMap = Arguments.createMap();
+            if (value == null) {
+                writableMap.putNull(key);
+            } else if (value instanceof Boolean) {
+                writableMap.putBoolean(key, (Boolean) value);
+            } else if (value instanceof Double) {
+                writableMap.putDouble(key, (Double) value);
+            } else if (value instanceof Integer) {
+                writableMap.putInt(key, (Integer) value);
+            } else if (value instanceof String) {
+                writableMap.putString(key, (String) value);
+            } else if (value instanceof Map) {
+                writableMap.putMap(key, MapUtil.toWritableMap((Map<String, Object>) value));
+            } else if (value.getClass() != null && (value.getClass().isArray() || value instanceof ArrayList)) {
+                writableMap.putArray(key, ArrayUtil.toWritableArray((ArrayList) value));
+            }
+            return writableMap;
+        }
+
+        public static class ArrayUtil {
+
+            public static JSONArray toJSONArray(ReadableArray readableArray) throws JSONException {
+                JSONArray jsonArray = new JSONArray();
+
+                for (int i = 0; i < readableArray.size(); i++) {
+                    ReadableType type = readableArray.getType(i);
+
+                    switch (type) {
+                        case Null:
+                            jsonArray.put(i, null);
+                            break;
+                        case Boolean:
+                            jsonArray.put(i, readableArray.getBoolean(i));
+                            break;
+                        case Number:
+                            jsonArray.put(i, readableArray.getDouble(i));
+                            break;
+                        case String:
+                            jsonArray.put(i, readableArray.getString(i));
+                            break;
+                        case Map:
+                            jsonArray.put(i, MapUtil.toJSONObject(readableArray.getMap(i)));
+                            break;
+                        case Array:
+                            jsonArray.put(i, ArrayUtil.toJSONArray(readableArray.getArray(i)));
+                            break;
+                    }
+                }
+
+                return jsonArray;
+            }
+
+            public static Object[] toArray(ReadableArray readableArray) {
+                Object[] array = new Object[readableArray.size()];
+
+                for (int i = 0; i < readableArray.size(); i++) {
+                    ReadableType type = readableArray.getType(i);
+
+                    switch (type) {
+                        case Null:
+                            array[i] = null;
+                            break;
+                        case Boolean:
+                            array[i] = readableArray.getBoolean(i);
+                            break;
+                        case Number:
+                            array[i] = readableArray.getDouble(i);
+                            break;
+                        case String:
+                            array[i] = readableArray.getString(i);
+                            break;
+                        case Map:
+                            array[i] = MapUtil.toMap(readableArray.getMap(i));
+                            break;
+                        case Array:
+                            array[i] = ArrayUtil.toArray(readableArray.getArray(i));
+                            break;
+                    }
+                }
+
+                return array;
+            }
+
+            public static WritableArray toWritableArray(ArrayList arrayList) {
+                WritableArray writableArray = Arguments.createArray();
+
+                for (int i = 0; i < arrayList.size(); i++) {
+                    Object value = arrayList.get(i);
+
+                    if (value == null) {
+                        writableArray.pushNull();
+                    }
+                    if (value instanceof Boolean) {
+                        writableArray.pushBoolean((Boolean) value);
+                    }
+                    if (value instanceof Double) {
+                        writableArray.pushDouble((Double) value);
+                    }
+                    if (value instanceof Integer) {
+                        writableArray.pushInt((Integer) value);
+                    }
+                    if (value instanceof String) {
+                        writableArray.pushString((String) value);
+                    }
+                    if (value instanceof Map) {
+                        writableArray.pushMap(MapUtil.toWritableMap((Map<String, Object>) value));
+                    }
+                    if (value.getClass().isArray()) {
+                        writableArray.pushArray(ArrayUtil.toWritableArray((ArrayList) value));
+                    }
+                }
+
+                return writableArray;
+            }
+        }
+    }
 }

package/clevertap-react-native.podspec

@@ -18,6 +18,6 @@ Pod::Spec.new do |s|
   s.preserve_paths = 'LICENSE.md', 'README.md', 'package.json', 'index.js'
   s.source_files   = 'ios/CleverTapReact/*.{h,m}'
 
-  s.dependency 'CleverTap-iOS-SDK', '4.2.2'
+  s.dependency 'CleverTap-iOS-SDK', '5.0.1'
   s.dependency 'React-Core'
 end

package/docs/Variables.md

@@ -0,0 +1,136 @@
+# Overview
+You can define variables using the CleverTap React Native SDK. When you define a variable in your code, you can sync them to the CleverTap Dashboard via the provided SDK methods.
+
+# Supported Variable Types
+
+Currently, CleverTap SDK supports the following variable types:
+
+- String
+- boolean
+- JSON Object
+- number
+
+# Define Variables
+
+Variables can be defined using the `defineVariables` method. You must provide the names and default values of the variables using a JSON Object. 
+
+```javascript
+let variables = {
+              'reactnative_var_string': 'reactnative_var_string_value',
+              'reactnative_var_map': {
+                'reactnative_var_map_string': 'reactnative_var_map_value'
+              },
+              'reactnative_var_int': 6,
+              'reactnative_var_float': 6.9,
+              'reactnative_var_boolean': true
+            };
+CleverTap.defineVariables(variables);
+```
+
+# Setup Callbacks
+
+CleverTap React Native SDK provides several callbacks for the developer to receive feedback from the SDK. You can use them as per your requirement, using all of them is not mandatory. They are as follows:
+
+- Status of fetch variables request
+- `onVariablesChanged`
+- `onValueChanged`
+
+## Status of Variables Fetch Request
+
+This method provides a boolean flag to ensure that the variables are successfully fetched from the server.
+
+```javascript
+CleverTap.fetchVariables((err, success) => {
+    console.log('fetchVariables result: ', success);
+});
+```
+
+## `onVariablesChanged`
+
+This callback is invoked when variables are initialized with values fetched from the server. It is called each time new values are fetched.
+
+```javascript
+CleverTap.onVariablesChanged((variables) => {
+    console.log('onVariablesChanged: ', variables);
+});
+```
+
+## `onValueChanged`
+
+This callback is invoked when the value of the variable changes. You must provide the name of the variable whose value needs to be observed.
+
+```javascript
+CleverTap.onValueChanged('reactnative_var_string', (variable) => {
+    console.log('onValueChanged: ', variable);
+});
+```
+
+# Sync Defined Variables
+
+After defining your variables in the code, you must send/sync variables to the server. To do so, the app must be in DEBUG mode and mark a particular CleverTap user profile as a test profile from the CleverTap dashboard. [Learn how to mark a profile as **Test Profile**](https://developer.clevertap.com/docs/concepts-user-profiles#mark-a-user-profile-as-a-test-profile)
+
+After marking the profile as a test profile, you must sync the app variables in DEBUG mode:
+
+```javascript
+// 1. Define CleverTap variables 
+// …
+// 2. Add variables/values changed callbacks
+// …
+
+// 3. Sync CleverTap Variables from DEBUG mode/builds
+CleverTap.syncVariables();
+```
+
+> 📘 Key Points to Remember
+> 
+> - In a scenario where there is already a draft created by another user profile in the dashboard, the sync call will fail to avoid overriding important changes made by someone else. In this case, Publish or Dismiss the existing draft before you proceed with syncing variables again. However, you can override a draft you created via the sync method previously to optimize the integration experience.
+> - You can receive the following console logs from the CleverTap SDK:
+>   - Variables synced successfully.
+>   - Unauthorized access from a non-test profile. Please mark this profile as a test profile from the CleverTap dashboard.
+
+# Fetch Variables During a Session
+
+You can fetch the updated values for your CleverTap variables from the server during a session. If variables have changed, the appropriate callbacks will be fired. The provided callback provides a boolean flag that indicates if the fetch call was successful. The callback is fired regardless of whether the variables have changed or not.
+
+```javascript
+ CleverTap.fetchVariables((err, success) => {
+    console.log('fetchVariables result: ', success);
+});
+```
+
+# Use Fetched Variables Values
+
+This process involves the following two major steps:
+
+1. Fetch variable values.
+2. Access variable values.
+
+## Fetch Variable Values
+
+Variables are updated automatically when server values are received. If you want to receive feedback when a specific variable is updated, use the individual callback:
+
+```javascript
+CleverTap.onValueChanged('reactnative_var_string', (variable) => {
+    console.log('onValueChanged: ', variable);
+});
+```
+
+## Access Variable Values
+
+You can access these fetched values in the following two ways:
+
+### Getting all variables
+
+```javascript
+CleverTap.getVariables((err, variables) => {
+    console.log('getVariables: ', variables, err);
+});
+```
+
+### Getting a specific variable
+
+```javascript
+CleverTap.getVariable('reactnative_var_string', (err, variable) => {
+    console.log(`variable value for key \'reactnative_var_string\': ${variable}`);
+});
+```

package/docs/callbackPayloadFormat.md

@@ -0,0 +1,26 @@
+##  🔖 Overview
+
+This document demonstrates the changes in the payload formats along with the platform affected. These changes make the payload consistent across Android and iOS platform from v1.1.0. 
+
+Refer [Sample App](https://github.com/CleverTap/clevertap-react-native/blob/master/Example/App.js) for examples on how to access the payload. 
+
+| Callback                                | Platform affected | Old Payload Format               | New Payload Format                                      | Remarks                                                                                                                                                                      |
+| --------------------------------------- | ----------------- | -------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CleverTapInAppNotificationButtonTapped  | iOS               | { "customExtras": {} }           | {}                                                      | Removed \`customExtras\` key                                                                                                                                                 |
+| CleverTapInAppNotificationDismissed     | iOS               | { "actionExtras": {} }           | { "extras": {}, "actionExtras": {} }                    | Started passing an empty Object to \`extras\` key when found null                                                                                                            |
+| CleverTapInAppNotificationShowed        | Android           | { "data": '{}' }                 | { "data": {} }                                          | Removed stringified JSON with plain JSON format to access payload without JSON parsing                                                                                       |
+| CleverTapPushNotificationClicked        | iOS               | { "customExtras": {} }           | {}                                                      | Removed \`customExtras\` key                                                                                                                                                 |
+| CleverTapPushPermissionResponseReceived | iOS               | { "isPermissionGranted": false } | { "accepted": false }                                   | Renamed \`isPersmissionGranted\` key to \`accepted\`                                                                                                                         |
+| CleverTapInboxDidInitialize             | iOS               | undefined                        | {}                                                      | Passed an empty Object when found null                                                                                                                                       |
+| CleverTapInboxMessagesDidUpdate         | iOS               | undefined                        | {}                                                      | Passed an empty Object when found null                                                                                                                                       |
+| CleverTapInboxMessageTapped             | Both              | { "data": '{}' }                 | { "data": {}, "contentPageIndex": 0, "buttonIndex": 1 } | \- Replaced stringified JSON with plain JSON format to access the \`data\` key without JSON parsing<br>\- Added \`contentPageIndex\` and \`buttonIndex\` keys to the payload |
+| CleverTapDisplayUnitsLoaded             | Android           | { "displayUnits": [ '{}' ] }     | { "displayUnits": [ {} ] }                              | Removed stringified JSON with plain JSON format to access payload without JSON parsing                                                                                       |
+| CleverTapFeatureFlagsDidUpdate          | iOS               | undefined                        | {}                                                      | Passed an empty Object when found null                                                                                                                                       |
+| CleverTapProductConfigDidInitialize     | iOS               | undefined                        | {}                                                      | Passed an empty Object when found null                                                                                                                                       |
+| CleverTapProductConfigDidFetch          | iOS               | undefined                        | {}                                                      | Passed an empty Object when found null                                                                                                                                       |
+| CleverTapProductConfigDidActivate       | iOS               | undefined                        | {}                                                      | Passed an empty Object when found null                                                                                                                                       |
+| getAllInboxMessages                     | Android           | [ '{}' , '{}' ]                  | [ {}, {} ]                                              | Removed stringified JSON with plain JSON format to access payload without JSON parsing                                                                                       |
+| getUnreadInboxMessages                  | Android           | [ '{}' , '{}' ]                  | [ {}, {} ]                                              | Removed stringified JSON with plain JSON format to access payload without JSON parsing                                                                                       |
+| getInboxMessageForId                    | Android           | "{}"                             | {}                                                      | Removed stringified JSON with plain JSON format to access payload without JSON parsing                                                                                       |
+| getAllDisplayUnits                      | Android           | [ '{}' , '{}' ]                  | [ {}, {} ]                                              | Removed stringified JSON with plain JSON format to access payload without JSON parsing                                                                                       |
+| getDisplayUnitForId                     | Android           | "{}"                             | {}                                                      | Removed stringified JSON with plain JSON format to access payload without JSON parsing                                                                                       |

package/docs/usage.md

@@ -104,6 +104,37 @@ CleverTap.showInbox({'tabs':['Offers','Promotions'],'navBarTitle':'My App Inbox'
                                 'noMessageText':'No message(s)','noMessageTextColor':'#FF0000'});
  ```
 
+#### App Inbox Item Click Callback
+
+```javascript 
+CleverTap.addListener(CleverTap.CleverTapInboxMessageTapped, (event) => {
+    console.log("App Inbox item: ", event.data);
+    //following contentPageIndex and buttonIndex fields are available from CleverTap React Native SDK v0.9.6 onwards and below v1.0.0 
+    console.log("Content Page index: " + event.contentPageIndex);
+    console.log("Button index: " + event.buttonIndex);
+});
+```
+
+#### App Inbox Button Click Callback
+```javascript
+CleverTap.addListener(CleverTap.CleverTapInboxMessageButtonTapped, (event) => {/*consume the payload*/});
+```
+
+#### Dismiss the App Inbox
+```javascript
+CleverTap.dismissInbox();
+```
+
+### Mark read all inbox messages by array of messageIds
+```javascript
+CleverTap.markReadInboxMessagesForIDs(['1', '2', '3']);	
+```
+
+### Delete all inbox messages by array of messageIds
+```javascript
+CleverTap.deleteInboxMessagesForIDs(['1', '2', '3']);	
+```
+
 #### Get Total message count
 
 ```javascript