@luciq/react-native 18.0.0

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqSurveysModule.java

@@ -0,0 +1,237 @@
+package ai.luciq.reactlibrary;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableArray;
+import ai.luciq.library.Feature;
+import ai.luciq.reactlibrary.utils.ArrayUtil;
+import ai.luciq.reactlibrary.utils.EventEmitterModule;
+import ai.luciq.reactlibrary.utils.LuciqUtil;
+import ai.luciq.reactlibrary.utils.MainThreadHandler;
+import ai.luciq.survey.callbacks.*;
+import ai.luciq.survey.Surveys;
+import ai.luciq.survey.Survey;
+
+import org.json.JSONArray;
+
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+public class RNLuciqSurveysModule extends EventEmitterModule {
+
+    public RNLuciqSurveysModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "LCQSurveys";
+    }
+
+    @ReactMethod
+    public void addListener(String event) {
+        super.addListener(event);
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        super.removeListeners(count);
+    }
+
+    /**
+     * Returns true if the survey with a specific token was answered before.
+     * Will return false if the token does not exist or if the survey was not answered before.
+     *
+     * @param surveyToken          the attribute key as string
+     * @param promise A promise that gets resolved with the returned value of whether
+     *                             the user has responded to the survey or not.
+     * @return the desired value of whether the user has responded to the survey or not.
+     */
+    @ReactMethod
+    public void hasRespondedToSurvey(final String surveyToken, final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean hasResponded = false;
+                try {
+                    hasResponded = Surveys.hasRespondToSurvey(surveyToken);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                promise.resolve(hasResponded);
+            }
+        });
+    }
+
+    /**
+     * Shows survey with a specific token.
+     * Does nothing if there are no available surveys with that specific token.
+     * Answered and cancelled surveys won't show up again.
+     *
+     * @param surveyToken A String with a survey token.
+     */
+    @ReactMethod
+    public void showSurvey(final String surveyToken) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Surveys.showSurvey(surveyToken);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Show any valid survey if exist
+     *
+     * @return true if a valid survey was shown otherwise false
+     */
+    @ReactMethod
+    public void showSurveysIfAvailable() {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Surveys.showSurveyIfAvailable();
+                } catch (java.lang.Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Show any valid survey if exist
+     *
+     * @return true if a valid survey was shown otherwise false
+     */
+    @ReactMethod
+    public void setEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (isEnabled) {
+                        Surveys.setState(Feature.State.ENABLED);
+                    } else {
+                        Surveys.setState(Feature.State.DISABLED);
+                    }
+                } catch (java.lang.Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets the runnable that gets executed just before showing any valid survey<br/>
+     * WARNING: This runs on your application's main UI thread. Please do not include
+     * any blocking operations to avoid ANRs.
+     *
+     * @param handler to run on the UI thread before showing any valid survey
+     */
+    @ReactMethod
+    public void setOnShowHandler(final Callback handler) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                Surveys.setOnShowCallback(new OnShowCallback() {
+                    @Override
+                    public void onShow() {
+                        sendEvent(Constants.LCQ_ON_SHOW_SURVEY_HANDLER, null);
+                    }
+                });
+            }
+        });
+    }
+
+    /**
+     * Sets the runnable that gets executed just after showing any valid survey<br/>
+     * WARNING: This runs on your application's main UI thread. Please do not include
+     * any blocking operations to avoid ANRs.
+     *
+     * @param handler to run on the UI thread after showing any valid survey
+     */
+    @ReactMethod
+    public void setOnDismissHandler(final Callback handler) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                Surveys.setOnDismissCallback(new OnDismissCallback() {
+                    @Override
+                    public void onDismiss() {
+                        sendEvent(Constants.LCQ_ON_DISMISS_SURVEY_HANDLER, null);
+                    }
+                });
+            }
+        });
+    }
+
+    /**
+     * Returns an array containing the available surveys.
+     */
+    @ReactMethod
+    public void getAvailableSurveys(final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    List<Survey> availableSurveys = Surveys.getAvailableSurveys();
+                    JSONArray surveysArray = LuciqUtil.surveyObjectToJson(availableSurveys);
+                    WritableArray array = ArrayUtil.convertJsonToWritableArray(surveysArray);
+                    promise.resolve(array);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    promise.resolve(Arguments.createArray());
+                }
+            }
+        });
+    }
+
+    /**
+     * Set Surveys auto-showing state, default state auto-showing enabled
+     *
+     * @param autoShowingSurveysEnabled whether Surveys should be auto-showing or not
+     */
+    @ReactMethod
+    public void setAutoShowingEnabled(final boolean autoShowingSurveysEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Surveys.setAutoShowingEnabled(autoShowingSurveysEnabled);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Set Surveys welcome screen enabled, default value is false
+     *
+     * @param shouldShow shouldShow whether should a welcome screen be shown
+     *                   before taking surveys or not
+     */
+    @ReactMethod
+    public void setShouldShowWelcomeScreen(final boolean shouldShow) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Surveys.setShouldShowWelcomeScreen(shouldShow);
+                } catch (java.lang.Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+        });
+    }
+}

package/android/src/main/java/ai/luciq/reactlibrary/utils/ArrayUtil.java

@@ -0,0 +1,167 @@
+/*
+  ArrayUtil exposes a set of helper methods for working with
+  ReadableArray (by React Native), Object[], and JSONArray.
+ */
+
+package ai.luciq.reactlibrary.utils;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.json.JSONException;
+
+public 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 WritableArray convertJsonToWritableArray(JSONArray jsonArray) throws JSONException {
+        WritableArray array = Arguments.createArray();
+
+        for (int i = 0; i < jsonArray.length(); i++) {
+            Object value = jsonArray.get(i);
+            if (value instanceof JSONObject) {
+                array.pushMap(MapUtil.convertJsonToWritableMap((JSONObject) value));
+            } else if (value instanceof  JSONArray) {
+                array.pushArray(convertJsonToWritableArray((JSONArray) value));
+            } else if (value instanceof  Boolean) {
+                array.pushBoolean((Boolean) value);
+            } else if (value instanceof  Integer) {
+                array.pushInt((Integer) value);
+            } else if (value instanceof  Double) {
+                array.pushDouble((Double) value);
+            } else if (value instanceof String)  {
+                array.pushString((String) value);
+            }
+        }
+        return array;
+    }
+
+    public static Object[] toArray(JSONArray jsonArray) throws JSONException {
+        Object[] array = new Object[jsonArray.length()];
+
+        for (int i = 0; i < jsonArray.length(); i++) {
+            Object value = jsonArray.get(i);
+
+            if (value instanceof JSONObject) {
+                value = MapUtil.toMap((JSONObject) value);
+            }
+            if (value instanceof JSONArray) {
+                value = ArrayUtil.toArray((JSONArray) value);
+            }
+
+            array[i] = value;
+        }
+
+        return array;
+    }
+
+    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(Object[] array) {
+        WritableArray writableArray = Arguments.createArray();
+
+        for (int i = 0; i < array.length; i++) {
+            Object value = array[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((Object[]) value));
+            }
+        }
+
+        return writableArray;
+    }
+
+    public static ArrayList<String> parseReadableArrayOfStrings(ReadableArray readableArray) {
+        ArrayList<String> array = new ArrayList<>();
+        for (int i = 0; i < readableArray.size(); i++) {
+            ReadableType type = readableArray.getType(i);
+            if (type == ReadableType.String) {
+                array.add(readableArray.getString(i));
+            }
+        }
+        return array;
+    }
+}

package/android/src/main/java/ai/luciq/reactlibrary/utils/EventEmitterModule.java

@@ -0,0 +1,35 @@
+package ai.luciq.reactlibrary.utils;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+public abstract class EventEmitterModule extends ReactContextBaseJavaModule {
+    private int listenerCount = 0;
+
+    public EventEmitterModule(ReactApplicationContext context) {
+        super(context);
+    }
+
+    @VisibleForTesting
+    public void sendEvent(String event, @Nullable ReadableMap params) {
+        if (listenerCount > 0) {
+            getReactApplicationContext()
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(event, params);
+        }
+    }
+
+    protected void addListener(String ignoredEvent) {
+        listenerCount++;
+    }
+
+    protected void removeListeners(Integer count) {
+        listenerCount -= count;
+    }
+}

package/android/src/main/java/ai/luciq/reactlibrary/utils/LuciqUtil.java

@@ -0,0 +1,58 @@
+package ai.luciq.reactlibrary.utils;
+
+import ai.luciq.survey.Survey;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+public class LuciqUtil {
+    public static Method getMethod(Class clazz, String methodName, Class... parameterType) {
+        final Method[] methods = clazz.getDeclaredMethods();
+
+        for (Method method : methods) {
+            if (method.getName().equals(methodName) && method.getParameterTypes().length ==
+                    parameterType.length) {
+                if (parameterType.length == 0) {
+                    method.setAccessible(true);
+                    return method;
+                }
+                for (int i = 0; i < parameterType.length; i++) {
+                    if (method.getParameterTypes()[i] == parameterType[i]) {
+                        if (i == method.getParameterTypes().length - 1) {
+                            method.setAccessible(true);
+                            return method;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Convenience method to convert from a list of Surveys to a JSON array
+     *
+     * @param list
+     *        List of Surveys to be converted to JSON array
+     */
+    public static JSONArray surveyObjectToJson(List<Survey> list) {
+        JSONArray jsonArray = new JSONArray();
+        try{
+            for (Survey obj : list) {
+                JSONObject object = new JSONObject();
+                object.put("title", obj.getTitle());
+                jsonArray.put(object);
+            }
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return jsonArray;
+    }
+
+}

package/android/src/main/java/ai/luciq/reactlibrary/utils/MainThreadHandler.java

@@ -0,0 +1,13 @@
+package ai.luciq.reactlibrary.utils;
+
+import android.os.Handler;
+import android.os.Looper;
+
+public class MainThreadHandler {
+    /**
+     * Runs a block of code on the Main Thread
+     */
+    public static void runOnMainThread(Runnable runnable) {
+        new Handler(Looper.getMainLooper()).post(runnable);
+    }
+}

package/android/src/main/java/ai/luciq/reactlibrary/utils/MapUtil.java

@@ -0,0 +1,171 @@
+/*
+  MapUtil exposes a set of helper methods for working with
+  ReadableMap (by React Native), Map<String, Object>, and JSONObject.
+ */
+
+package ai.luciq.reactlibrary.utils;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.json.JSONException;
+
+public 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(JSONObject jsonObject) throws JSONException {
+        Map<String, Object> map = new HashMap<>();
+        Iterator<String> iterator = jsonObject.keys();
+
+        while (iterator.hasNext()) {
+            String key = iterator.next();
+            Object value = jsonObject.get(key);
+
+            if (value instanceof JSONObject) {
+                value = MapUtil.toMap((JSONObject) value);
+            }
+            if (value instanceof JSONArray) {
+                value = ArrayUtil.toArray((JSONArray) value);
+            }
+
+            map.put(key, value);
+        }
+
+        return map;
+    }
+
+    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();
+            Object value = pair.getValue();
+
+            if (value == null) {
+                writableMap.putNull((String) pair.getKey());
+            } else if (value instanceof Boolean) {
+                writableMap.putBoolean((String) pair.getKey(), (Boolean) value);
+            } else if (value instanceof Double) {
+                writableMap.putDouble((String) pair.getKey(), (Double) value);
+            } else if (value instanceof Integer) {
+                writableMap.putInt((String) pair.getKey(), (Integer) value);
+            } else if (value instanceof String) {
+                writableMap.putString((String) pair.getKey(), (String) value);
+            } else if (value instanceof Map) {
+                writableMap.putMap((String) pair.getKey(), MapUtil.toWritableMap((Map<String,
+                        Object>) value));
+            } else if (value.getClass() != null && value.getClass().isArray()) {
+                writableMap.putArray((String) pair.getKey(), ArrayUtil.toWritableArray((Object[])
+                        value));
+            }
+
+            iterator.remove();
+        }
+
+        return writableMap;
+    }
+
+    public static WritableMap convertJsonToWritableMap(JSONObject jsonObject) throws JSONException {
+        WritableMap map = new WritableNativeMap();
+
+        Iterator<String> iterator = jsonObject.keys();
+        while (iterator.hasNext()) {
+            String key = iterator.next();
+            Object value = jsonObject.get(key);
+            if (value instanceof JSONObject) {
+                map.putMap(key, convertJsonToWritableMap((JSONObject) value));
+            } else if (value instanceof  JSONArray) {
+                map.putArray(key, ArrayUtil.convertJsonToWritableArray((JSONArray) value));
+            } else if (value instanceof  Boolean) {
+                map.putBoolean(key, (Boolean) value);
+            } else if (value instanceof  Integer) {
+                map.putInt(key, (Integer) value);
+            } else if (value instanceof  Double) {
+                map.putDouble(key, (Double) value);
+            } else if (value instanceof String)  {
+                map.putString(key, (String) value);
+            } else {
+                map.putString(key, value.toString());
+            }
+        }
+        return map;
+    }
+
+}