reactnative-plugin-appice 1.6.3 → 1.6.4

package/android/build.gradle

@@ -114,7 +114,7 @@ dependencies {
     annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.3.1"
 
     //appice
-    implementation 'appice.io.android:sdk:2.5.61-release'
+    implementation 'appice.io.android:sdk:2.5.62'
 
     //glide
     implementation "com.github.bumptech.glide:glide:4.11.0"

package/android/src/main/java/com/reactlibrary/AppICEUtils.java

@@ -3,13 +3,24 @@ package com.reactlibrary;
 import android.util.Log;
 
 import com.facebook.react.bridge.Arguments;
+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 org.json.JSONArray;
+import org.json.JSONException;
 import org.json.JSONObject;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 
+import semusi.context.ui.appInbox.AppICEInboxMessage;
+
 public class AppICEUtils {
     private static final String TAG = "AppICEUtils";
 
@@ -35,4 +46,206 @@ public class AppICEUtils {
         return extrasParams;
     }
 
+    public static WritableMap convertClassToWritableMap(AppICEInboxMessage inboxMessage){
+        WritableMap inboxObject = Arguments.createMap();
+        try {
+            if (inboxMessage != null) {
+                inboxObject.putString(Constants.INBOX_MESSAGE_ID, inboxMessage.getMessageId());
+                inboxObject.putString(Constants.INBOX_CAMPAIGN_ID, inboxMessage.getCampId());
+                inboxObject.putString(Constants.INBOX_CAMPAIGN_TYPE, inboxMessage.getMessageCampType());
+                inboxObject.putString(Constants.INBOX_MESSAGE_CATEGORY, inboxMessage.getCategory());
+                inboxObject.putString(Constants.INBOX_MESSAGE_STATUS, inboxMessage.getMessageStatus());
+                inboxObject.putString(Constants.INBOX_MESSAGE_LANGUAGE, inboxMessage.getMessageLanguage());
+                inboxObject.putString(Constants.INBOX_TITLE, inboxMessage.getMessageTitle());
+                inboxObject.putString(Constants.INBOX_MESSAGE, inboxMessage.getMessageBody());
+                inboxObject.putString(Constants.INBOX_MESSAGE_ICON, inboxMessage.getMessageIcon());
+                inboxObject.putMap(Constants.INBOX_CUSTOM_DATA, toWritableMap(inboxMessage.getCustomData()));
+            }
+        }catch (Throwable throwable){}
+        return inboxObject;
+    }
+
+
+    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()));
+        }
+
+        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, toWritableMap((Map<String, Object>) value));
+        } else if (value.getClass() != null && (value.getClass().isArray() || value instanceof ArrayList)) {
+            writableMap.putArray(key, toWritableArray((ArrayList) value));
+        }
+        return writableMap;
+    }
+
+    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(toWritableMap((Map<String, Object>) value));
+            }
+            if (value.getClass().isArray()) {
+                writableArray.pushArray(toWritableArray((ArrayList) value));
+            }
+        }
+
+        return writableArray;
+    }
+
+
+    public 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;
+    }
+
+    public 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;
+    }
+
+    public 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;
+    }
+
+    /**
+     * @param propsMap took data from js and iterate it and store in hashmap
+     * @return map of the props data
+     */
+    public static HashMap<String, Object> eventPropsFromReadableMap(ReadableMap propsMap) {
+        if (propsMap == null) return null;
+
+        HashMap<String, Object> props = new HashMap<>();
+        ReadableMapKeySetIterator iterator = propsMap.keySetIterator();
+
+        while (iterator.hasNextKey()) {
+            try {
+                String key = iterator.nextKey();
+                ReadableType readableType = propsMap.getType(key);
+
+                if (readableType == ReadableType.String) {
+                    props.put(key, propsMap.getString(key));
+                } else if (readableType == ReadableType.Boolean) {
+                    props.put(key, propsMap.getBoolean(key));
+                } else if (readableType == ReadableType.Number) {
+                    try {
+                        props.put(key, propsMap.getDouble(key));
+                    } catch (Throwable t) {
+                        try {
+                            props.put(key, propsMap.getInt(key));
+                        } catch (Throwable t1) {
+                            Log.d(TAG, "Unhandled ReadableType.Number from ReadableMap");
+                        }
+                    }
+                } else {
+                    Log.d(TAG, "Unhandled event property ReadableType");
+                }
+            } catch (Throwable t) {
+                Log.d(TAG, t.getLocalizedMessage());
+            }
+        }
+        return props;
+    }
+
+    public static void printLog(String TAG, String message){
+        System.out.println(TAG+", "+message);
+    }
 }