@dashx/react-native 0.1.25 → 1.0.2

package/android/src/main/java/com/dashx/rn/sdk/util/ArrayUtil.java

@@ -0,0 +1,163 @@
+
+/*
+  ArrayUtil exposes a set of helper methods for working with
+  ReadableArray (by React Native), Object[], and JSONArray.
+
+  MIT License
+
+  Copyright (c) 2020 Marc Mendiola
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+ */
+
+package com.dashx.rn.sdk.util;
+
+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.Arrays;
+import java.util.List;
+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 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 List<Object> toList(ReadableArray readableArray) {
+    return Arrays.asList(toArray(readableArray));
+  }
+
+  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;
+  }
+}

package/android/src/main/java/com/dashx/rn/sdk/util/MapUtil.java

@@ -0,0 +1,168 @@
+/*
+  MapUtil exposes a set of helper methods for working with
+  ReadableMap (by React Native), Map<String, Object>, and JSONObject.
+
+  MIT License
+
+  Copyright (c) 2020 Marc Mendiola
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+ */
+
+package com.dashx.rn.sdk.util;
+
+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 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<>();
+
+    if(readableMap == null) {
+      return map;
+    }
+
+    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;
+  }
+}

package/android/src/main/java/com/dashx/rn/sdk/{Utils.kt → util/Utils.kt}

@@ -1,6 +1,6 @@
 @file:JvmName("Utils")
 
-package com.dashx.rn.sdk
+package com.dashx.rn.sdk.util
 
 import com.facebook.react.bridge.*
 import com.google.gson.JsonArray
@@ -45,8 +45,8 @@ fun convertArrayToJson(readableArray: ReadableArray?): JsonArray {
 @JvmOverloads
 @Throws(Exception::class)
 fun convertToWritableMap(
-    map: Map<*, *>,
-    blacklist: List<String> = emptyList<String>()
+        map: Map<*, *>,
+        blacklist: List<String> = emptyList<String>()
 ): WritableMap {
     val writableMap: WritableMap = WritableNativeMap()
     val iterator: Iterator<String> = map.keys.iterator() as Iterator<String>
@@ -54,7 +54,7 @@ fun convertToWritableMap(
         val key = iterator.next()
 
         if (blacklist.contains(key)) {
-            continue;
+            continue
         }
 
         when (val value = map[key]) {
@@ -128,4 +128,4 @@ fun ReadableMap.getStringIfPresent(key: String): String? {
 
 fun ReadableMap.getBooleanIfPresent(key: String): Boolean? {
     return if (this.hasKey(key)) this.getBoolean(key) else null
-}
+}

package/index.js

@@ -1,89 +1,69 @@
-import { NativeEventEmitter, NativeModules } from 'react-native'
-import { parseFilterObject, toContentSingleton } from './utils'
-import {
-  prepareExternalAsset,
-  queryExternalAsset,
-  uploadExternalAsset,
-} from './utils/RestAPIClient'
+import { NativeEventEmitter, NativeModules } from "react-native";
+import { parseFilterObject, toContentSingleton } from "./utils";
 
-import ContentOptionsBuilder from './ContentOptionsBuilder'
+import ContentOptionsBuilder from "./ContentOptionsBuilder";
 
-const { DashX } = NativeModules
-const dashXEventEmitter = new NativeEventEmitter(DashX)
+const { DashXReactNative: DashX } = NativeModules;
 
-//TODO Get connection config from Android layer as well
-const { identify, track, fetchContent, searchContent, getConnectionConfig } =
-  DashX
+const dashXEventEmitter = new NativeEventEmitter(DashX);
+
+const {
+	identify,
+	setIdentity,
+	track,
+	fetchContent,
+	searchContent,
+	uploadExternalAsset,
+	prepareExternalAsset,
+	externalAsset,
+} = DashX;
 
-// Handle overloads at JS, because Native modules doesn't allow that
-// https://github.com/facebook/react-native/issues/19116
 DashX.identify = (options) => {
-  if (typeof options === 'string') {
-    return identify(options, null) // options is a string ie. uid
-  } else {
-    return identify(null, options)
-  }
-}
+	return identify(options);
+};
 
-DashX.track = (event, data) => track(event, data || null)
+DashX.setIdentity = (uid, token) => {
+	return setIdentity(uid, token);
+};
 
-DashX.getConnectionConfig = () => {
-  return getConnectionConfig()
-}
+DashX.track = (event, data) => track(event, data || null);
 
 DashX.searchContent = (contentType, options) => {
-  if (!options) {
-    return new ContentOptionsBuilder((wrappedOptions) =>
-      searchContent(contentType, wrappedOptions)
-    )
-  }
+	if (!options) {
+		return new ContentOptionsBuilder((wrappedOptions) =>
+			searchContent(contentType, wrappedOptions)
+		);
+	}
 
-  const filter = parseFilterObject(options.filter)
+	const filter = parseFilterObject(options.filter);
 
-  const result = searchContent(contentType, { ...options, filter })
+	const result = searchContent(contentType, { ...options, filter });
 
-  if (options.returnType === 'all') {
-    return result
-  }
+	if (options.returnType === "all") {
+		return result;
+	}
 
-  return result.then(toContentSingleton)
-}
+	return result.then(toContentSingleton);
+};
 
 DashX.fetchContent = (contentType, options) => {
-  return fetchContent(contentType, options)
-}
-
-DashX.uploadExternalAsset = async (file, externalColumnId) => {
-  const connectionConfig = await getConnectionConfig()
-
-  return new Promise((resolve, reject) => {
-    uploadExternalAsset(
-      file,
-      externalColumnId,
-      connectionConfig,
-      resolve,
-      reject
-    )
-  })
-}
-
-DashX.prepareExternalAsset = async (externalColumnId) => {
-  const connectionConfig = await getConnectionConfig()
-
-  return new Promise((resolve, reject) => {
-    prepareExternalAsset(externalColumnId, connectionConfig, resolve, reject)
-  })
-}
-
-DashX.externalAsset = async (assetId) => {
-  const connectionConfig = await getConnectionConfig()
-
-  return new Promise((resolve, reject) => {
-    queryExternalAsset(assetId, connectionConfig, resolve, reject)
-  })
-}
-
-DashX.onMessageReceived = (callback) =>
-  dashXEventEmitter.addListener('messageReceived', callback)
-
-export default DashX
+	return fetchContent(contentType, options);
+};
+
+DashX.uploadExternalAsset = (file, externalColumnId) => {
+	return uploadExternalAsset(file, externalColumnId);
+};
+
+DashX.prepareExternalAsset = (externalColumnId) => {
+	return prepareExternalAsset(externalColumnId);
+};
+
+DashX.externalAsset = (assetId) => {
+	return externalAsset(assetId);
+};
+
+DashX.onMessageReceived = (callback) => {
+	dashXEventEmitter.addListener("messageReceived", callback);
+};
+
+export default DashX;