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

package/android/src/main/java/com/github/wuxudong/rncharts/data/RadarDataExtract.java

@@ -0,0 +1,58 @@
+package com.github.wuxudong.rncharts.data;
+
+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.data.RadarData;
+import com.github.mikephil.charting.data.RadarDataSet;
+import com.github.mikephil.charting.data.RadarEntry;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.utils.ChartDataSetConfigUtils;
+import com.github.wuxudong.rncharts.utils.ConversionUtil;
+
+import java.util.ArrayList;
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+public class RadarDataExtract extends DataExtract<RadarData, RadarEntry> {
+
+    @Override
+    RadarData createData() {
+        return new RadarData();
+    }
+
+    @Override
+    IDataSet<RadarEntry> createDataSet(ArrayList<RadarEntry> entries, String label) {
+        return new RadarDataSet(entries, label);
+    }
+
+    @Override
+    void dataSetConfig(Chart chart, IDataSet<RadarEntry> dataSet, ReadableMap config) {
+        RadarDataSet radarDataSet = (RadarDataSet) dataSet;
+
+        ChartDataSetConfigUtils.commonConfig(chart, radarDataSet, config);
+        ChartDataSetConfigUtils.commonLineScatterCandleRadarConfig(radarDataSet, config);
+        ChartDataSetConfigUtils.commonLineRadarConfig(radarDataSet, config);
+
+        // RadarDataSet only config
+    }
+
+    @Override
+    RadarEntry createEntry(ReadableArray values, int index) {
+        RadarEntry entry;
+
+        if (ReadableType.Map.equals(values.getType(index))) {
+            ReadableMap map = values.getMap(index);
+            float value = (float) map.getDouble("value");
+            entry = new RadarEntry(value, ConversionUtil.toMap(map));
+        } else if (ReadableType.Number.equals(values.getType(index))) {
+            entry = new RadarEntry((float) values.getDouble(index));
+        } else {
+            throw new IllegalArgumentException("Unexpected entry type: " + values.getType(index));
+        }
+        return entry;
+    }
+
+}

package/android/src/main/java/com/github/wuxudong/rncharts/data/ScatterDataExtract.java

@@ -0,0 +1,75 @@
+package com.github.wuxudong.rncharts.data;
+
+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.charts.ScatterChart;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.data.ScatterData;
+import com.github.mikephil.charting.data.ScatterDataSet;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+import com.github.wuxudong.rncharts.utils.ChartDataSetConfigUtils;
+import com.github.wuxudong.rncharts.utils.ConversionUtil;
+
+import java.util.ArrayList;
+import java.util.Locale;
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+public class ScatterDataExtract extends DataExtract<ScatterData, Entry> {
+    @Override
+    ScatterData createData() {
+        return new ScatterData();
+    }
+
+    @Override
+    IDataSet<Entry> createDataSet(ArrayList<Entry> entries, String label) {
+        return new ScatterDataSet(entries, label);
+    }
+
+    @Override
+    void dataSetConfig(Chart chart, IDataSet<Entry> dataSet, ReadableMap config) {
+        ScatterDataSet scatterDataSet = (ScatterDataSet) dataSet;
+
+        ChartDataSetConfigUtils.commonConfig(chart, scatterDataSet, config);
+        ChartDataSetConfigUtils.commonBarLineScatterCandleBubbleConfig(scatterDataSet, config);
+        ChartDataSetConfigUtils.commonLineScatterCandleRadarConfig(scatterDataSet, config);
+
+        // ScatterDataSet only config
+        if (BridgeUtils.validate(config, ReadableType.Number, "scatterShapeSize")) {
+            scatterDataSet.setScatterShapeSize((float) config.getDouble("scatterShapeSize"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.String, "scatterShape")) {
+            scatterDataSet.setScatterShape(ScatterChart.ScatterShape.valueOf(config.getString("scatterShape").toUpperCase(Locale.ENGLISH)));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "scatterShapeHoleColor")) {
+            scatterDataSet.setScatterShapeHoleColor(config.getInt("scatterShapeHoleColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "scatterShapeHoleRadius")) {
+            scatterDataSet.setScatterShapeHoleRadius((float) config.getDouble("scatterShapeHoleRadius"));
+        }
+    }
+
+    @Override
+    Entry createEntry(ReadableArray values, int index) {
+        float x = index;
+
+        Entry entry;
+        if (ReadableType.Map.equals(values.getType(index))) {
+            ReadableMap map = values.getMap(index);
+            if (map.hasKey("x")) {
+                x = (float) map.getDouble("x");
+            }
+            entry = new Entry(x, (float) map.getDouble("y"), ConversionUtil.toMap(map));
+        } else if (ReadableType.Number.equals(values.getType(index))) {
+            entry = new Entry(x, (float) values.getDouble(index));
+        } else {
+            throw new IllegalArgumentException("Unexpected entry type: " + values.getType(index));
+        }
+
+        return entry;
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/listener/RNOnChartGestureListener.java

@@ -0,0 +1,129 @@
+package com.github.wuxudong.rncharts.listener;
+
+import androidx.annotation.NonNull;
+import android.view.MotionEvent;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.github.mikephil.charting.charts.BarLineChartBase;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.components.YAxis;
+import com.github.mikephil.charting.listener.ChartTouchListener;
+import com.github.mikephil.charting.listener.OnChartGestureListener;
+import com.github.mikephil.charting.utils.MPPointD;
+import com.github.mikephil.charting.utils.ViewPortHandler;
+import com.github.wuxudong.rncharts.charts.ChartGroupHolder;
+
+import java.lang.ref.WeakReference;
+
+/**
+ * Created by xudong on 07/03/2017.
+ */
+public class RNOnChartGestureListener implements OnChartGestureListener {
+
+    private WeakReference<Chart> mWeakChart;
+
+    private String group = null;
+
+    private String identifier = null;
+
+    public RNOnChartGestureListener(Chart chart) {
+        this.mWeakChart = new WeakReference<>(chart);
+    }
+
+    public void setGroup(String group) {
+        this.group = group;
+    }
+
+    public void setIdentifier(String identifier) {
+        this.identifier = identifier;
+    }
+
+    @Override
+    public void onChartGestureStart(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture) {
+        sendEvent("chartGestureStart", me);
+    }
+
+    @Override
+    public void onChartGestureEnd(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture) {
+        sendEvent("chartGestureEnd", me);
+    }
+
+    @Override
+    public void onChartLongPressed(MotionEvent me) {
+        sendEvent("chartLongPress", me);
+    }
+
+    @Override
+    public void onChartDoubleTapped(MotionEvent me) {
+        sendEvent("doubleTapped", me);
+    }
+
+    @Override
+    public void onChartSingleTapped(MotionEvent me) {
+        sendEvent("chartSingleTap", me);
+    }
+
+    @Override
+    public void onChartFling(MotionEvent me1, MotionEvent me2, float velocityX, float velocityY) {
+        sendEvent("chartFling", me1);
+    }
+
+    @Override
+    public void onChartScale(MotionEvent me, float scaleX, float scaleY) {
+        sendEvent("chartScaled", me);
+    }
+
+    @Override
+    public void onChartTranslate(MotionEvent me, float dX, float dY) {
+        sendEvent("chartTranslated", me);
+    }
+
+    private void sendEvent(String action, MotionEvent me) {
+        Chart chart = mWeakChart.get();
+        if (chart != null) {
+
+            WritableMap event = getEvent(action, me, chart);
+
+            ReactContext reactContext = (ReactContext) chart.getContext();
+            reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+                    chart.getId(),
+                    "topChange",
+                    event);
+        }
+    }
+
+    @NonNull
+    private WritableMap getEvent(String action, MotionEvent me, Chart chart) {
+        WritableMap event = Arguments.createMap();
+
+        event.putString("action", action);
+
+        if (chart instanceof BarLineChartBase) {
+            BarLineChartBase barLineChart = (BarLineChartBase) chart;
+            ViewPortHandler viewPortHandler = chart.getViewPortHandler();
+            event.putDouble("scaleX", chart.getScaleX());
+            event.putDouble("scaleY", chart.getScaleY());
+
+            MPPointD center = ((BarLineChartBase) chart).getValuesByTouchPoint(viewPortHandler.getContentCenter().getX(), viewPortHandler.getContentCenter().getY(), YAxis.AxisDependency.LEFT);
+            event.putDouble("centerX", center.x);
+            event.putDouble("centerY", center.y);
+
+            MPPointD leftBottom = ((BarLineChartBase) chart).getValuesByTouchPoint(viewPortHandler.contentLeft(), viewPortHandler.contentBottom(), YAxis.AxisDependency.LEFT);
+            MPPointD rightTop = ((BarLineChartBase) chart).getValuesByTouchPoint(viewPortHandler.contentRight(), viewPortHandler.contentTop(), YAxis.AxisDependency.LEFT);
+
+            event.putDouble("left", leftBottom.x);
+            event.putDouble("bottom", leftBottom.y);
+            event.putDouble("right", rightTop.x);
+            event.putDouble("top", rightTop.y);
+
+            if (group != null && identifier != null) {
+                ChartGroupHolder.sync(group, identifier, chart.getScaleX(), chart.getScaleY(), (float) center.x, (float) center.y);
+
+            }
+        }
+        return event;
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/listener/RNOnChartValueSelectedListener.java

@@ -0,0 +1,52 @@
+package com.github.wuxudong.rncharts.listener;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.highlight.Highlight;
+import com.github.mikephil.charting.listener.OnChartValueSelectedListener;
+import com.github.wuxudong.rncharts.utils.EntryToWritableMapUtils;
+
+import java.lang.ref.WeakReference;
+
+/**
+ * Created by xudong on 07/03/2017.
+ */
+public class RNOnChartValueSelectedListener implements OnChartValueSelectedListener {
+
+    private WeakReference<Chart> mWeakChart;
+
+    public RNOnChartValueSelectedListener(Chart chart) {
+        mWeakChart = new WeakReference<>(chart);
+    }
+
+    @Override
+    public void onValueSelected(Entry entry, Highlight h) {
+
+        if (mWeakChart != null) {
+            Chart chart = mWeakChart.get();
+
+            ReactContext reactContext = (ReactContext) chart.getContext();
+            reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+                    chart.getId(),
+                    "topSelect",
+                    EntryToWritableMapUtils.convertEntryToWritableMap(entry));
+        }
+    }
+
+    @Override
+    public void onNothingSelected() {
+        if (mWeakChart != null) {
+            Chart chart = mWeakChart.get();
+
+            ReactContext reactContext = (ReactContext) chart.getContext();
+            reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+                    chart.getId(),
+                    "topSelect",
+                    null);
+        }
+
+    }
+
+}

package/android/src/main/java/com/github/wuxudong/rncharts/markers/RNCircleMarkerView.java

@@ -0,0 +1,19 @@
+package com.github.wuxudong.rncharts.markers;
+
+import com.github.mikephil.charting.components.MarkerView;
+import android.content.Context;
+
+import com.github.mikephil.charting.utils.MPPointF;
+import com.github.wuxudong.rncharts.R;
+
+public class RNCircleMarkerView extends MarkerView {
+    public RNCircleMarkerView(Context context) {
+        //the super will take care of displaying the layout
+        super(context, R.layout.circle_marker);
+    }
+
+    @Override
+    public MPPointF getOffset() {
+        return new MPPointF(-(getWidth() / 2), -getHeight() / 2);
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/markers/RNRectangleMarkerView.java

@@ -0,0 +1,134 @@
+package com.github.wuxudong.rncharts.markers;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import androidx.core.content.res.ResourcesCompat;
+import android.text.TextUtils;
+import android.widget.TextView;
+
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.components.MarkerView;
+import com.github.mikephil.charting.data.CandleEntry;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.highlight.Highlight;
+import com.github.mikephil.charting.utils.MPPointF;
+import com.github.mikephil.charting.utils.Utils;
+import com.github.wuxudong.rncharts.R;
+
+import java.util.List;
+import java.util.Map;
+
+public class RNRectangleMarkerView extends MarkerView {
+
+    private TextView tvContent;
+
+    private Drawable backgroundLeft = ResourcesCompat.getDrawable(getResources(), R.drawable.rectangle_marker_left, null);
+    private Drawable background = ResourcesCompat.getDrawable(getResources(), R.drawable.rectangle_marker, null);
+    private Drawable backgroundRight = ResourcesCompat.getDrawable(getResources(), R.drawable.rectangle_marker_right, null);
+
+    private Drawable backgroundTopLeft = ResourcesCompat.getDrawable(getResources(), R.drawable.rectangle_marker_top_left, null);
+    private Drawable backgroundTop = ResourcesCompat.getDrawable(getResources(), R.drawable.rectangle_marker_top, null);
+    private Drawable backgroundTopRight = ResourcesCompat.getDrawable(getResources(), R.drawable.rectangle_marker_top_right, null);
+
+    private int digits = 0;
+
+    public RNRectangleMarkerView(Context context) {
+        super(context, R.layout.rectangle_marker);
+
+        tvContent = (TextView) findViewById(R.id.rectangle_tvContent);
+    }
+
+    public void setDigits(int digits) {
+        this.digits = digits;
+    }
+
+    @Override
+    public void refreshContent(Entry e, Highlight highlight) {
+        String text;
+
+        if (e instanceof CandleEntry) {
+            CandleEntry ce = (CandleEntry) e;
+            text = Utils.formatNumber(ce.getClose(), digits, false);
+        } else {
+            text = Utils.formatNumber(e.getY(), digits, false);
+        }
+
+        if (e.getData() instanceof Map) {
+            if (((Map) e.getData()).containsKey("marker")) {
+
+                Object marker = ((Map) e.getData()).get("marker");
+                text = marker.toString();
+
+                if (highlight.getStackIndex() != -1 && marker instanceof List) {
+                    text = ((List) marker).get(highlight.getStackIndex()).toString();
+                }
+
+            }
+        }
+
+        if (TextUtils.isEmpty(text)) {
+            tvContent.setVisibility(INVISIBLE);
+        } else {
+            tvContent.setText(text);
+            tvContent.setVisibility(VISIBLE);
+        }
+
+        super.refreshContent(e, highlight);
+    }
+
+    @Override
+    public MPPointF getOffset() {
+        return new MPPointF(-(getWidth() / 2), -getHeight());
+    }
+
+    @Override
+    public MPPointF getOffsetForDrawingAtPoint(float posX, float posY) {
+
+        MPPointF offset = getOffset();
+
+        MPPointF offset2 = new MPPointF();
+
+        offset2.x = offset.x;
+        offset2.y = offset.y;
+
+        Chart chart = getChartView();
+
+        float width = getWidth();
+
+        if (posX + offset2.x < 0) {
+            offset2.x = 0;
+
+            if (posY + offset2.y < 0) {
+                offset2.y = 0;
+                tvContent.setBackground(backgroundTopLeft);
+            } else {
+                tvContent.setBackground(backgroundLeft);
+            }
+
+        } else if (chart != null && posX + width + offset2.x > chart.getWidth()) {
+            offset2.x = -width;
+
+            if (posY + offset2.y < 0) {
+                offset2.y = 0;
+                tvContent.setBackground(backgroundTopRight);
+            } else {
+                tvContent.setBackground(backgroundRight);
+            }
+        } else {
+            if (posY + offset2.y < 0) {
+                offset2.y = 0;
+                tvContent.setBackground(backgroundTop);
+            } else {
+                tvContent.setBackground(background);
+            }
+        }
+
+        return offset2;
+    }
+
+    public TextView getTvContent() {
+        return tvContent;
+    }
+
+}
+

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

@@ -0,0 +1,52 @@
+package com.github.wuxudong.rncharts.utils;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+
+public class BridgeUtils {
+
+    public static boolean validate(ReadableMap map, ReadableType propType, String propName) {
+        return map.hasKey(propName) && propType.equals(map.getType(propName));
+    }
+
+    public static int[] convertToIntArray(ReadableArray readableArray) {
+        int[] array = new int[readableArray.size()];
+
+        for (int i = 0; i < readableArray.size(); i++) {
+            if (!ReadableType.Number.equals(readableArray.getType(i))) {
+                throw new IllegalArgumentException("Expecting array of numbers");
+            }
+            array[i] = readableArray.getInt(i);
+        }
+
+        return array;
+    }
+
+    public static float[] convertToFloatArray(ReadableArray readableArray) {
+        float[] array = new float[readableArray.size()];
+
+        for (int i = 0; i < readableArray.size(); i++) {
+            if (!ReadableType.Number.equals(readableArray.getType(i))) {
+                throw new IllegalArgumentException("Expecting array of numbers");
+            }
+            array[i] = (float) readableArray.getDouble(i);
+        }
+
+        return array;
+    }
+
+    public static String[] convertToStringArray(ReadableArray readableArray) {
+        String[] array = new String[readableArray.size()];
+
+        for (int i = 0; i < readableArray.size(); i++) {
+            if (!ReadableType.String.equals(readableArray.getType(i))) {
+                throw new IllegalArgumentException("Expecting array of strings");
+            }
+            array[i] = readableArray.getString(i);
+        }
+
+        return array;
+    }
+
+}