@urvish-procare/react-native-charts-wrapper 0.6.0

package/android/src/main/java/com/github/wuxudong/rncharts/utils/ChartDataSetConfigUtils.java

@@ -0,0 +1,197 @@
+package com.github.wuxudong.rncharts.utils;
+
+import android.graphics.drawable.GradientDrawable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.components.YAxis;
+import com.github.mikephil.charting.data.BarLineScatterCandleBubbleDataSet;
+import com.github.mikephil.charting.data.DataSet;
+import com.github.mikephil.charting.data.LineRadarDataSet;
+import com.github.mikephil.charting.data.LineScatterCandleRadarDataSet;
+import com.github.mikephil.charting.formatter.LargeValueFormatter;
+import com.github.mikephil.charting.formatter.PercentFormatter;
+import com.github.wuxudong.rncharts.charts.CustomFormatter;
+import com.github.wuxudong.rncharts.charts.DateFormatter;
+import com.github.wuxudong.rncharts.charts.IndexValueFormatter;
+import com.github.wuxudong.rncharts.charts.LabelByXValueFormatter;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * https://github.com/PhilJay/MPAndroidChart/wiki/The-DataSet-class
+ * https://github.com/PhilJay/MPAndroidChart/wiki/DataSet-classes-in-detail
+ */
+public class ChartDataSetConfigUtils {
+
+    public static void commonConfig(Chart chart, DataSet dataSet, ReadableMap config) {
+        // Setting main color
+        if (BridgeUtils.validate(config, ReadableType.Number, "color")) {
+            dataSet.setColor(config.getInt("color"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Array, "colors")) {
+            dataSet.setColors(BridgeUtils.convertToIntArray(config.getArray("colors")));
+        }
+
+        // TODO more config to add: https://github.com/PhilJay/MPAndroidChart/wiki/The-DataSet-class
+
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "drawValues")) {
+            dataSet.setDrawValues(config.getBoolean("drawValues"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "highlightEnabled")) {
+            dataSet.setHighlightEnabled(config.getBoolean("highlightEnabled"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "visible")) {
+            dataSet.setVisible(config.getBoolean("visible"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "valueTextSize")) {
+            dataSet.setValueTextSize((float) config.getDouble("valueTextSize"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "valueTextColor")) {
+            dataSet.setValueTextColor(config.getInt("valueTextColor"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.String, "valueFormatter")) {
+            String valueFormatter = config.getString("valueFormatter");
+
+            if ("largeValue".equals(valueFormatter)) {
+                dataSet.setValueFormatter(new LargeValueFormatter());
+            } else if ("percent".equals(valueFormatter)) {
+                dataSet.setValueFormatter(new PercentFormatter());
+            } else if ("date".equals(valueFormatter)) {
+                String valueFormatterPattern = config.getString("valueFormatterPattern");
+
+                long since = 0;
+                if (BridgeUtils.validate(config, ReadableType.Number, "since")) {
+                    since = (long) config.getDouble("since");
+                }
+
+                TimeUnit timeUnit = TimeUnit.MILLISECONDS;
+
+                if (BridgeUtils.validate(config, ReadableType.String, "timeUnit")) {
+                    timeUnit = TimeUnit.valueOf(config.getString("timeUnit").toUpperCase());
+                }
+
+                Locale locale = Locale.getDefault();
+
+                if (BridgeUtils.validate(config, ReadableType.String, "locale")) {
+                    locale = Locale.forLanguageTag(config.getString("locale"));
+                }
+
+                dataSet.setValueFormatter(new DateFormatter(valueFormatterPattern, since, timeUnit, locale));
+            } else if ("labelByXValue".equals(valueFormatter)) {
+                ReadableArray valueFormatterLabels = config.getArray("valueFormatterLabels");
+
+                Map<Float, String> labelsByXValue = new HashMap<>();
+                for (int index = 0; index < valueFormatterLabels.size(); index++) {
+                    ReadableMap entry = valueFormatterLabels.getMap(index);
+                    labelsByXValue.put(Float.valueOf((float) entry.getDouble("x")), entry.getString("label"));
+                }
+
+                dataSet.setValueFormatter(new LabelByXValueFormatter(labelsByXValue));
+            } else {
+                dataSet.setValueFormatter(new CustomFormatter(valueFormatter));
+            }
+        } else if (BridgeUtils.validate(config, ReadableType.Array, "valueFormatter")) {
+            dataSet.setValueFormatter(new IndexValueFormatter(BridgeUtils.convertToStringArray(config.getArray("valueFormatter"))));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.String, "axisDependency")) {
+            dataSet.setAxisDependency(YAxis.AxisDependency.valueOf(config.getString("axisDependency").toUpperCase(Locale.ENGLISH)));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.String, "fontFamily")) {
+            dataSet.setValueTypeface(TypefaceUtils.getTypeface(chart, config));
+        }
+
+    }
+
+    public static void commonBarLineScatterCandleBubbleConfig(BarLineScatterCandleBubbleDataSet dataSet, ReadableMap config) {
+        if (BridgeUtils.validate(config, ReadableType.Number, "highlightColor")) {
+            dataSet.setHighLightColor(config.getInt("highlightColor"));
+        }
+    }
+
+    public static void commonLineScatterCandleRadarConfig(LineScatterCandleRadarDataSet dataSet, ReadableMap config) {
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "drawHighlightIndicators")) {
+            dataSet.setDrawHighlightIndicators(config.getBoolean("drawHighlightIndicators"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "drawVerticalHighlightIndicator")) {
+            dataSet.setDrawVerticalHighlightIndicator(config.getBoolean("drawVerticalHighlightIndicator"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "drawHorizontalHighlightIndicator")) {
+            dataSet.setDrawHorizontalHighlightIndicator(config.getBoolean("drawHorizontalHighlightIndicator"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "highlightLineWidth")) {
+            dataSet.setHighlightLineWidth((float) config.getDouble("highlightLineWidth"));
+        }
+    }
+
+    public static void commonLineRadarConfig(LineRadarDataSet dataSet, ReadableMap config) {
+
+        if (BridgeUtils.validate(config, ReadableType.Map, "fillGradient")) {
+            int[] colors = BridgeUtils.convertToIntArray(config.getMap("fillGradient").getArray("colors"));
+
+            GradientDrawable.Orientation orientation = GradientDrawable.Orientation.BOTTOM_TOP;
+
+            switch (config.getMap("fillGradient").getString("orientation")) {
+                case "TOP_BOTTOM":
+                    orientation = GradientDrawable.Orientation.TOP_BOTTOM;
+                    break;
+                case "TR_BL":
+                    orientation = GradientDrawable.Orientation.TR_BL;
+                    break;
+                case "RIGHT_LEFT":
+                    orientation = GradientDrawable.Orientation.RIGHT_LEFT;
+                    break;
+                case "BR_TL":
+                    orientation = GradientDrawable.Orientation.BR_TL;
+                    break;
+                case "BOTTOM_TOP":
+                    orientation = GradientDrawable.Orientation.BOTTOM_TOP;
+                    break;
+                case "BL_TR":
+                    orientation = GradientDrawable.Orientation.BL_TR;
+                    break;
+                case "LEFT_RIGHT":
+                    orientation = GradientDrawable.Orientation.LEFT_RIGHT;
+                    break;
+                case "TL_BR":
+                    orientation = GradientDrawable.Orientation.TL_BR;
+                    break;
+            }
+
+            GradientDrawable gd = new GradientDrawable(
+                    orientation,
+                    colors);
+            gd.setCornerRadius(0f);
+            gd.setAlpha(config.getInt("fillAlpha"));
+            dataSet.setFillDrawable(gd);
+        } else if (BridgeUtils.validate(config, ReadableType.Number, "fillColor")) {
+            dataSet.setFillColor(config.getInt("fillColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "fillAlpha")) {
+            dataSet.setFillAlpha(config.getInt("fillAlpha"));
+        }
+        // TODO setFillDrawable android.graphics.drawable.Drawable
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "drawFilled")) {
+            dataSet.setDrawFilled(config.getBoolean("drawFilled"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "lineWidth")) {
+            float lineWidth = (float) config.getDouble("lineWidth");
+            if (lineWidth >= 0.2f && lineWidth < 10f) {
+                dataSet.setLineWidth(lineWidth);
+            }
+        }
+    }
+
+}

package/android/src/main/java/com/github/wuxudong/rncharts/utils/ConversionUtil.java

@@ -0,0 +1,144 @@
+/**
+ * ConversionUtil.java
+ * react-native-eval
+ * <p>
+ * Created by Andy Prock on 9/24/15.
+ */
+
+package com.github.wuxudong.rncharts.utils;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+/**
+ * Helper utilities to convert from react-native types to POJOs
+ */
+public final class ConversionUtil {
+    /**
+     * toObject extracts a value from a {@link ReadableMap} by its key,
+     * and returns a POJO representing that object.
+     *
+     * @param readableMap The Map to containing the value to be converted
+     * @param key The key for the value to be converted
+     * @return The converted POJO
+     */
+    public static Object toObject(@Nullable ReadableMap readableMap, String key) {
+        if (readableMap == null) {
+            return null;
+        }
+
+        Object result;
+
+        ReadableType readableType = readableMap.getType(key);
+        switch (readableType) {
+            case Null:
+                result = key;
+                break;
+            case Boolean:
+                result = readableMap.getBoolean(key);
+                break;
+            case Number:
+                // Can be int or double.
+                double tmp = readableMap.getDouble(key);
+                if (tmp == (int) tmp) {
+                    result = (int) tmp;
+                } else {
+                    result = tmp;
+                }
+                break;
+            case String:
+                result = readableMap.getString(key);
+                break;
+            case Map:
+                result = toMap(readableMap.getMap(key));
+                break;
+            case Array:
+                result = toList(readableMap.getArray(key));
+                break;
+            default:
+                throw new IllegalArgumentException("Could not convert object with key: " + key + ".");
+        }
+
+        return result;
+    }
+
+    /**
+     * toMap converts a {@link ReadableMap} into a HashMap.
+     *
+     * @param readableMap The ReadableMap to be conveted.
+     * @return A HashMap containing the data that was in the ReadableMap.
+     */
+    public static Map<String, Object> toMap(@Nullable ReadableMap readableMap) {
+        if (readableMap == null) {
+            return null;
+        }
+
+        com.facebook.react.bridge.ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+        if (!iterator.hasNextKey()) {
+            return null;
+        }
+
+        Map<String, Object> result = new HashMap<>();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            result.put(key, toObject(readableMap, key));
+        }
+
+        return result;
+    }
+
+    /**
+     * toList converts a {@link ReadableArray} into an ArrayList.
+     *
+     * @param readableArray The ReadableArray to be conveted.
+     * @return An ArrayList containing the data that was in the ReadableArray.
+     */
+    public static List<Object> toList(@Nullable ReadableArray readableArray) {
+        if (readableArray == null) {
+            return null;
+        }
+
+        List<Object> result = new ArrayList<>(readableArray.size());
+        for (int index = 0; index < readableArray.size(); index++) {
+            ReadableType readableType = readableArray.getType(index);
+            switch (readableType) {
+                case Null:
+                    result.add(String.valueOf(index));
+                    break;
+                case Boolean:
+                    result.add(readableArray.getBoolean(index));
+                    break;
+                case Number:
+                    // Can be int or double.
+                    double tmp = readableArray.getDouble(index);
+                    if (tmp == (int) tmp) {
+                        result.add((int) tmp);
+                    } else {
+                        result.add(tmp);
+                    }
+                    break;
+                case String:
+                    result.add(readableArray.getString(index));
+                    break;
+                case Map:
+                    result.add(toMap(readableArray.getMap(index)));
+                    break;
+                case Array:
+                    result = toList(readableArray.getArray(index));
+                    break;
+                default:
+                    throw new IllegalArgumentException("Could not convert object with index: " + index + ".");
+            }
+        }
+
+        return result;
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/utils/DrawableUtils.java

@@ -0,0 +1,51 @@
+package com.github.wuxudong.rncharts.utils;
+
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.os.AsyncTask;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+public class DrawableUtils {
+    public static Drawable drawableFromUrl(String url, final int width, final int height) {
+        try {
+            return new DrawableLoadingAsyncTask().execute(url, Integer.toString(width), Integer.toString(height)).get();
+        } catch (Exception e) {
+            // draw dummy drawable when execution fail
+            e.printStackTrace();
+            return new ShapeDrawable();
+        }
+    }
+
+    static class DrawableLoadingAsyncTask extends AsyncTask<String, Void, Drawable> {
+        @Override
+        protected Drawable doInBackground(String... strings) {
+            try {
+                Bitmap x;
+
+                int width = Integer.parseInt(strings[1]);
+                int height = Integer.parseInt(strings[2]);
+
+                HttpURLConnection connection = (HttpURLConnection) new URL(strings[0]).openConnection();
+                connection.connect();
+                InputStream input = connection.getInputStream();
+
+                x = BitmapFactory.decodeStream(input);
+
+                return new BitmapDrawable(Resources.getSystem(), Bitmap.createScaledBitmap(x, width, height, true));
+
+            } catch(IOException e) {
+                e.printStackTrace();
+                // draw dummy drawable when connection fail
+                return new ShapeDrawable();
+            }
+        }
+    };
+}

package/android/src/main/java/com/github/wuxudong/rncharts/utils/EasingFunctionHelper.java

@@ -0,0 +1,128 @@
+package com.github.wuxudong.rncharts.utils;
+
+import com.github.mikephil.charting.animation.Easing;
+
+import static com.github.mikephil.charting.animation.Easing.EaseInBack;
+import static com.github.mikephil.charting.animation.Easing.EaseInBounce;
+import static com.github.mikephil.charting.animation.Easing.EaseInCirc;
+import static com.github.mikephil.charting.animation.Easing.EaseInCubic;
+import static com.github.mikephil.charting.animation.Easing.EaseInElastic;
+import static com.github.mikephil.charting.animation.Easing.EaseInExpo;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutBack;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutBounce;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutCirc;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutCubic;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutElastic;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutExpo;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutQuad;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutQuart;
+import static com.github.mikephil.charting.animation.Easing.EaseInOutSine;
+import static com.github.mikephil.charting.animation.Easing.EaseInQuad;
+import static com.github.mikephil.charting.animation.Easing.EaseInQuart;
+import static com.github.mikephil.charting.animation.Easing.EaseInSine;
+import static com.github.mikephil.charting.animation.Easing.EaseOutBack;
+import static com.github.mikephil.charting.animation.Easing.EaseOutBounce;
+import static com.github.mikephil.charting.animation.Easing.EaseOutCirc;
+import static com.github.mikephil.charting.animation.Easing.EaseOutCubic;
+import static com.github.mikephil.charting.animation.Easing.EaseOutElastic;
+import static com.github.mikephil.charting.animation.Easing.EaseOutExpo;
+import static com.github.mikephil.charting.animation.Easing.EaseOutQuad;
+import static com.github.mikephil.charting.animation.Easing.EaseOutQuart;
+import static com.github.mikephil.charting.animation.Easing.EaseOutSine;
+import static com.github.mikephil.charting.animation.Easing.Linear;
+
+
+public class EasingFunctionHelper {
+
+    public static Easing.EasingFunction getEasingFunction(String name) {
+        switch (name) {
+            case "Linear":
+                return Linear;
+
+            case "EaseInQuad":
+                return EaseInQuad;
+
+            case "EaseOutQuad":
+                return EaseOutQuad;
+
+            case "EaseInOutQuad":
+                return EaseInOutQuad;
+
+            case "EaseInCubic":
+                return EaseInCubic;
+
+            case "EaseOutCubic":
+                return EaseOutCubic;
+
+            case "EaseInOutCubic":
+                return EaseInOutCubic;
+
+            case "EaseInQuart":
+                return EaseInQuart;
+
+            case "EaseOutQuart":
+                return EaseOutQuart;
+
+            case "EaseInOutQuart":
+                return EaseInOutQuart;
+
+            case "EaseInSine":
+                return EaseInSine;
+
+            case "EaseOutSine":
+                return EaseOutSine;
+
+            case "EaseInOutSine":
+                return EaseInOutSine;
+
+            case "EaseInExpo":
+                return EaseInExpo;
+
+            case "EaseOutExpo":
+                return EaseOutExpo;
+
+            case "EaseInOutExpo":
+                return EaseInOutExpo;
+
+            case "EaseInCirc":
+                return EaseInCirc;
+
+            case "EaseOutCirc":
+                return EaseOutCirc;
+
+            case "EaseInOutCirc":
+                return EaseInOutCirc;
+
+            case "EaseInElastic":
+                return EaseInElastic;
+
+            case "EaseOutElastic":
+                return EaseOutElastic;
+
+            case "EaseInOutElastic":
+                return EaseInOutElastic;
+
+            case "EaseInBack":
+                return EaseInBack;
+
+            case "EaseOutBack":
+                return EaseOutBack;
+
+            case "EaseInOutBack":
+                return EaseInOutBack;
+
+            case "EaseInBounce":
+                return EaseInBounce;
+
+            case "EaseOutBounce":
+                return EaseOutBounce;
+
+            case "EaseInOutBounce":
+                return EaseInOutBounce;
+
+            default:
+                return Linear;
+
+        }
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/utils/EntryToWritableMapUtils.java

@@ -0,0 +1,147 @@
+package com.github.wuxudong.rncharts.utils;
+
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.github.mikephil.charting.data.BarEntry;
+import com.github.mikephil.charting.data.BubbleEntry;
+import com.github.mikephil.charting.data.CandleEntry;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.data.PieEntry;
+import com.github.mikephil.charting.data.RadarEntry;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * Helper utilities to convert from Entry to WritableMap
+ */
+public final class EntryToWritableMapUtils {
+    public static WritableMap convertEntryToWritableMap(Entry entry) {
+        if(entry == null) {
+            return null;
+        }
+
+        WritableMap map = new WritableNativeMap();
+
+        if(entry.getData() instanceof Map) {
+            map.putMap("data", convertMapToWritableMap((Map) entry.getData()));
+        }
+
+        if (entry instanceof BarEntry) {
+            BarEntry barEntry = (BarEntry) entry;
+
+            map.putDouble("x", entry.getX());
+
+            if (barEntry.getYVals() != null) {
+                WritableArray array = new WritableNativeArray();
+                for (float f: barEntry.getYVals()) {
+                    array.pushDouble(f);
+                }
+
+                map.putArray("yValues", array);
+            } else {
+                map.putDouble("y", entry.getY());
+            }
+        } else if (entry instanceof BubbleEntry) {
+            BubbleEntry bubbleEntry = (BubbleEntry) entry;
+
+            map.putDouble("x", entry.getX());
+            map.putDouble("y", entry.getY());
+
+            map.putDouble("size", bubbleEntry.getSize());
+        } else if (entry instanceof CandleEntry) {
+            CandleEntry candleEntry = (CandleEntry) entry;
+
+            map.putDouble("x", entry.getX());
+
+            map.putDouble("open", candleEntry.getOpen());
+            map.putDouble("close", candleEntry.getClose());
+            map.putDouble("low", candleEntry.getLow());
+            map.putDouble("high", candleEntry.getHigh());
+        } else if (entry instanceof PieEntry) {
+            PieEntry pieEntry = (PieEntry) entry;
+
+            map.putDouble("value", pieEntry.getValue());
+            map.putString("label", pieEntry.getLabel());
+        } else if (entry instanceof RadarEntry) {
+            RadarEntry radarEntry = (RadarEntry) entry;
+
+            map.putDouble("value", radarEntry.getValue());
+        } else {
+            map.putDouble("x", entry.getX());
+            map.putDouble("y", entry.getY());
+
+        }
+
+        return map;
+    }
+
+    private static WritableMap convertMapToWritableMap(Map map) {
+        return convertJsonToWritableMap(new JSONObject(map));
+    }
+
+    private static WritableMap convertJsonToWritableMap(JSONObject jsonObject) {
+        if(jsonObject == null) {
+            return null;
+        }
+
+        WritableMap map = new WritableNativeMap();
+
+        try {
+            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, 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());
+                }
+            }
+        } catch(JSONException ex) {
+            map.putString("error", "Failed to convert JSONObject to WritableMap: " + ex.getMessage());
+        }
+
+        return map;
+    }
+
+    private static WritableArray convertJsonToWritableArray(JSONArray jsonArray) throws JSONException {
+        WritableArray array = new WritableNativeArray();
+
+        for (int i = 0; i < jsonArray.length(); i++) {
+            Object value = jsonArray.get(i);
+            if (value instanceof JSONObject) {
+                array.pushMap(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);
+            } else {
+                array.pushString(value.toString());
+            }
+        }
+        return array;
+    }
+}