Java Examples for org.achartengine.model.XYMultipleSeriesDataset

/**
   * Creates a combined XY chart view.
   * 
   * @param context the context
   * @param dataset the multiple series dataset (cannot be null)
   * @param renderer the multiple series renderer (cannot be null)
   * @param types the chart types (cannot be null)
   * @return a combined XY chart graphical view
   * @throws IllegalArgumentException if dataset is null or renderer is null or
   *           if a dataset number of items is different than the number of
   *           series renderers or number of chart types
   */
public static final GraphicalView getCombinedXYChartView(Context context, XYMultipleSeriesDataset dataset, XYMultipleSeriesRenderer renderer, String[] types) {
    if (dataset == null || renderer == null || types == null || dataset.getSeriesCount() != types.length) {
        throw new IllegalArgumentException("Dataset, renderer and types should be not null and the datasets series count should be equal to the types length");
    }
    checkParameters(dataset, renderer);
    CombinedXYChart chart = new CombinedXYChart(dataset, renderer, types);
    return new GraphicalView(context, chart);
}

/**
   * Creates a combined XY chart view.
   * 
   * @param context the context
   * @param dataset the multiple series dataset (cannot be null)
   * @param renderer the multiple series renderer (cannot be null)
   * @param types the chart types (cannot be null)
   * @return a combined XY chart graphical view
   * @throws IllegalArgumentException if dataset is null or renderer is null or
   *           if a dataset number of items is different than the number of
   *           series renderers or number of chart types
   */
public static final GraphicalView getCombinedXYChartView(Context context, XYMultipleSeriesDataset dataset, XYMultipleSeriesRenderer renderer, String[] types) {
    if (dataset == null || renderer == null || types == null || dataset.getSeriesCount() != types.length) {
        throw new IllegalArgumentException("Dataset, renderer and types should be not null and the datasets series count should be equal to the types length");
    }
    checkParameters(dataset, renderer);
    CombinedXYChart chart = new CombinedXYChart(dataset, renderer, types);
    return new GraphicalView(context, chart);
}

/**
   * Creates a time chart intent that can be used to start the graphical view
   * activity.
   * 
   * @param context the context
   * @param dataset the multiple series dataset (cannot be null)
   * @param renderer the multiple series renderer (cannot be null)
   * @param format the date format pattern to be used for displaying the X axis
   *          date labels. If null, a default appropriate format will be used
   * @param activityTitle the graphical chart activity title
   * @return a time chart intent
   * @throws IllegalArgumentException if dataset is null or renderer is null or
   *           if the dataset and the renderer don't include the same number of
   *           series
   */
public static final Intent getTimeChartIntent(Context context, XYMultipleSeriesDataset dataset, XYMultipleSeriesRenderer renderer, String format, String activityTitle) {
    checkParameters(dataset, renderer);
    Intent intent = new Intent(context, GraphicalActivity.class);
    TimeChart chart = new TimeChart(dataset, renderer);
    chart.setDateFormat(format);
    intent.putExtra(CHART, chart);
    intent.putExtra(TITLE, activityTitle);
    return intent;
}

private XYMultipleSeriesDataset getDemoDataset() {
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    final int nr = 10;
    Random r = new Random();
    for (int i = 0; i < SERIES_NR; i++) {
        XYSeries series = new XYSeries("Demo series " + (i + 1));
        for (int k = 0; k < nr; k++) {
            series.add(k, 20 + r.nextInt() % 100);
        }
        dataset.addSeries(series);
    }
    return dataset;
}

public XYMultipleSeriesDataset buildDateDataset(String[] titles, List<Date[]> xValues, List<double[]> yValues) {
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        XYSeries series = new XYSeries(titles[i]);
        Date[] xV = xValues.get(i);
        double[] yV = yValues.get(i);
        int seriesLength = xV.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(xV[k].getTime(), yV[k]);
        }
        dataset.addSeries(series);
    }
    return dataset;
}

//private int mFillColorEnd = Color.argb(0xff,  0x6d,  0xad,  0xce);
private void createChartRendererSeriesAndView(Context context) {
    // The color values are from the iOS version...
    //int areaTopColor = Color.argb(0xff,  0xb8,  0xd3,  0xe1);
    //SKApplication appInstance = SKApplication.getAppInstance();
    //Context context = appInstance.getApplicationContext();
    Resources resources = context.getResources();
    int areaEndColor = resources.getColor(R.color.GraphColourTopAreaFill);
    int lineColor = resources.getColor(R.color.GraphColourTopLine);
    int gridLineColor = resources.getColor(R.color.GraphColourVerticalGridLine);
    // Create the multiple-series renderer... you might have more than one series
    // plotted at once, if you wanted, through this API...
    // XYMultipleSeriesRenderer multipleSeriesRenderer = new XYMultipleSeriesRenderer();
    multipleSeriesRenderer = new XYMultipleSeriesRenderer();
    multipleSeriesRenderer.setApplyBackgroundColor(true);
    // This is the graph BACKGROUND color
    multipleSeriesRenderer.setBackgroundColor(Color.WHITE);
    // This is the color that SURROUNDS the graph
    multipleSeriesRenderer.setMarginsColor(Color.WHITE);
    multipleSeriesRenderer.setAntialiasing(true);
    multipleSeriesRenderer.setChartTitle("");
    multipleSeriesRenderer.setClickEnabled(false);
    // Always show both axes
    multipleSeriesRenderer.setAxesColor(Color.LTGRAY);
    //multipleSeriesRenderer.setAxesColor(Color.TRANSPARENT);
    multipleSeriesRenderer.setLabelsColor(Color.BLACK);
    multipleSeriesRenderer.setXLabelsColor(Color.BLACK);
    // 0 is the scale - a mystery value!
    multipleSeriesRenderer.setYLabelsColor(0, Color.BLACK);
    multipleSeriesRenderer.setYLabelsPadding(5);
    multipleSeriesRenderer.setYLabelsAlign(Paint.Align.RIGHT);
    // Needs to be fairly, to cater for e.g. 0.008 type values!
    multipleSeriesRenderer.setLabelsTextSize(12);
    NumberFormat format = NumberFormat.getNumberInstance();
    format.setMaximumFractionDigits(3);
    multipleSeriesRenderer.setLabelFormat(format);
    //multipleSeriesRenderer.setChartValuesFormat(format);
    multipleSeriesRenderer.setLegendTextSize(15);
    multipleSeriesRenderer.setPanEnabled(false);
    //multipleSeriesRenderer.setPointSize(3f);
    multipleSeriesRenderer.setShowAxes(true);
    multipleSeriesRenderer.setShowGridX(false);
    multipleSeriesRenderer.setShowGridY(true);
    multipleSeriesRenderer.setGridColor(gridLineColor);
    multipleSeriesRenderer.setShowLegend(false);
    multipleSeriesRenderer.setShowLabels(true);
    multipleSeriesRenderer.setZoomButtonsVisible(false);
    multipleSeriesRenderer.setZoomEnabled(false);
    multipleSeriesRenderer.setZoomEnabled(false, false);
    multipleSeriesRenderer.setAxisTitleTextSize(16);
    // Pixels: top/left/bottom/right
    multipleSeriesRenderer.setMargins(new int[] { 20, 40, 15, 5 });
    multipleSeriesRenderer.setChartTitleTextSize(20);
    // The next two lines prevent the Y axis zero from being suppressed!
    multipleSeriesRenderer.setYAxisMin(0.0);
    //  * 1.05); // Allow border at top, for the points to draw in the case of 24-hour mod!
    multipleSeriesRenderer.setYAxisMax(this.corePlotMaxValue);
    // http://stackoverflow.com/questions/13216619/android-chart-with-dates-on-x-axis?rq=1
    // multipleSeriesRenderer.setXRoundedLabels(true);
    //multipleSeriesRenderer.setYTitle(mYAxisTitle);
    //multipleSeriesRenderer.setSelectableBuffer(20);
    // Create the series renderer - we have just one of these.
    XYSeriesRenderer seriesRenderer = new XYSeriesRenderer();
    seriesRenderer.setColor(lineColor);
    //        if (mDateRange == DATERANGE_1w1m3m1y.DATERANGE_1w1m3m1y_ONE_DAY) {
    //        	// 24-hour mode - just plot hourly averages!
    //        	seriesRenderer.setPointStyle(PointStyle.CIRCLE);
    //        	seriesRenderer.setFillPoints(true);
    //        	seriesRenderer.setPointStrokeWidth(10);
    //        	
    //        } else 
    {
        // Tell the line to fill below!
        FillOutsideLine fillOutsideLine = new FillOutsideLine(XYSeriesRenderer.FillOutsideLine.Type.BELOW);
        fillOutsideLine.setColor(areaEndColor);
        seriesRenderer.addFillOutsideLine(fillOutsideLine);
        // TODO - might be possible to use a gradient at some point?
        //seriesRenderer.setGradientEnabled(true);
        //seriesRenderer.setGradientStart(0, areaTopColor);
        //seriesRenderer.setGradientStop(0,  areaEndColor);
        // Show points, filled!
        seriesRenderer.setPointStyle(PointStyle.CIRCLE);
        //seriesRenderer.setFillPoints(true);
        seriesRenderer.setPointStrokeWidth(8);
    }
    // Add the series renderer to the multiple series renderer...
    multipleSeriesRenderer.addSeriesRenderer(seriesRenderer);
    // Create a series, and it it to the dataset...
    mTimeSeries = new TimeSeries("");
    // Create a dataset, and add the series to it...
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(mTimeSeries);
    // Finally: create the chart graphical view!
    if (mDateRange == DATERANGE_1w1m3m1y.DATERANGE_1w1m3m1y_ONE_DAY) {
        // 24-hour format - just show time!
        mGraphicalView = ChartFactory.getTimeChartView(context, dataset, multipleSeriesRenderer, SKDateFormat.sGetGraphTimeFormat());
        //        	int lLabels = multipleSeriesRenderer.getXLabels();
        //        	multipleSeriesRenderer.setXLabels(0);
        //        	int i;
        //        	for (i = 0; i < 5; i++) {
        //          	  multipleSeriesRenderer.addXTextLabel(i,  "Wow!");
        //        	}
        //        	
        multipleSeriesRenderer.setXLabels(0);
    } else {
        // 1 week or more - show date!
        mGraphicalView = ChartFactory.getTimeChartView(context, dataset, multipleSeriesRenderer, SKDateFormat.sGetGraphDateFormat(context));
    }
// Now that we have the chart, we'll be able to add-in some data...
// and add to the ViewGroup... straight after this call!
}

public void addBarChart(View view) {
    pie.getBackground().setColorFilter(0xFF37474f, PorterDuff.Mode.MULTIPLY);
    bar.getBackground().setColorFilter(0xFFff3d00, PorterDuff.Mode.MULTIPLY);
    line.getBackground().setColorFilter(0xFF37474f, PorterDuff.Mode.MULTIPLY);
    List<String> names = new ArrayList<String>();
    // Creating an XYSeries for Income
    XYSeries earnedSeries = new XYSeries("Earned");
    XYSeries totalSeries = new XYSeries("Total");
    // Adding data to Income and Expense Series
    float maxWeight = 0;
    for (int i = 0; i < mAssignments.size(); i++) {
        earnedSeries.add(i, (mAssignments.get(i).getGrade() * mAssignments.get(i).getWeight() * .01));
        totalSeries.add(i, mAssignments.get(i).getWeight());
        if (mAssignments.get(i).getWeight() > maxWeight) {
            maxWeight = mAssignments.get(i).getWeight();
        }
    }
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(earnedSeries);
    dataset.addSeries(totalSeries);
    // Creating XYSeriesRenderer to customize incomeSeries
    XYSeriesRenderer earnedRenderer = new XYSeriesRenderer();
    earnedRenderer.setColor(Color.rgb(228, 26, 28));
    earnedRenderer.setFillPoints(true);
    earnedRenderer.setLineWidth(2);
    earnedRenderer.setDisplayChartValues(true);
    // Creating a XYMultipleSeriesRenderer to customize the whole chart
    XYMultipleSeriesRenderer multiRenderer = new XYMultipleSeriesRenderer();
    multiRenderer.setXLabels(0);
    for (int i = 0; i < mAssignments.size(); i++) {
        multiRenderer.addXTextLabel(i, mAssignments.get(i).getName());
    }
    // Creating XYSeriesRenderer to customize expenseSeries
    XYSeriesRenderer totalRenderer = new XYSeriesRenderer();
    totalRenderer.setColor(Color.rgb(55, 126, 184));
    totalRenderer.setFillPoints(true);
    totalRenderer.setLineWidth(2);
    totalRenderer.setDisplayChartValues(true);
    // Adding incomeRenderer and expenseRenderer to multipleRenderer
    // Note: The order of adding dataseries to dataset and renderers to multipleRenderer
    // should be same
    multiRenderer.addSeriesRenderer(earnedRenderer);
    multiRenderer.addSeriesRenderer(totalRenderer);
    multiRenderer.setBarSpacing(.2);
    multiRenderer.setMarginsColor(Color.WHITE);
    multiRenderer.setYAxisMin(0);
    multiRenderer.setYAxisMax(maxWeight);
    multiRenderer.setXAxisMin(-1);
    multiRenderer.setLabelsTextSize(20);
    // Creating an intent to plot bar chart using dataset and multipleRenderer
    LinearLayout layout = (LinearLayout) findViewById(R.id.chart_layout);
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
    if (mChartView != null) {
        layout.removeView(mChartView);
    }
    mChartView = ChartFactory.getBarChartView(this, dataset, multiRenderer, BarChart.Type.DEFAULT);
    mChartView.setLayoutParams(params);
    layout.addView(mChartView);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    XYMultipleSeriesDataset dataset = createData();
    XYMultipleSeriesRenderer render = renderGraph();
    Intent intent = ChartFactory.getLineChartIntent(this, dataset, render);
    startActivity(intent);
}

private void constructAreaChart() {
    renderer = new XYMultipleSeriesRenderer();
    timeseries = new TimeSeries("");
    timeseries.add(new Date().getDate(), 0);
    dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(timeseries);
    XYSeriesRenderer seriesrenderer = new XYSeriesRenderer();
    renderer.addSeriesRenderer(seriesrenderer);
    setColors();
    seriesrenderer.setPointStyle(PointStyle.CIRCLE);
    seriesrenderer.setFillPoints(true);
    seriesrenderer.setChartValuesSpacing(2);
    seriesrenderer.setFillBelowLine(true);
    seriesrenderer.setColor(getResources().getColor(R.color.light_blue));
    seriesrenderer.setFillBelowLineColor(getResources().getColor(R.color.mid_blue));
    seriesrenderer.setLineWidth(2);
    //mChartView = ChartFactory.getCubeLineChartView(context, dataset, renderer, 0);
    mChartView = ChartFactory.getTimeChartView(context, dataset, renderer, "MM/dd HH:00");
}

private void onChartMenu() {
    SpeedOverTimeChart analysis = new SpeedOverTimeChart(this.model);
    XYMultipleSeriesDataset dataset = analysis.createDataset();
    XYMultipleSeriesRenderer renderer = analysis.createRenderer();
    if (dataset != null && renderer != null) {
        try {
            Intent intent = ChartFactory.getTimeChartIntent(this, dataset, renderer, "HH:mm");
            //				Intent intent = ChartFactory.getLineChartIntent(this, dataset,renderer);
            startActivity(intent);
        } catch (Exception ex) {
            Utilities.LogError("ERROR CHART", ex);
        }
    } else {
        Utilities.LogDebug(String.format("Dataset - %s\nRenderer - ", dataset.toString(), renderer.toString()));
    }
}

private XYMultipleSeriesDataset getAnytimeSeriesDataset(DailyVolumeUsage[] usage) {
    // Set daily accum objects and initialise
    long anytimeDailyAccum = 0;
    long uploadDailyAccum = 0;
    long quotaDailyAccum = 0;
    // Set String value categories for graph
    CategorySeries anytimeSeries = new CategorySeries(mContext.getString(R.string.chart_data_series_anytime));
    CategorySeries uploadSeries = new CategorySeries(mContext.getString(R.string.chart_data_series_upload));
    CategorySeries anytimeQuotaSeries = new CategorySeries(mContext.getString(R.string.chart_data_series_anytime_quota));
    // Get average daily useage
    long quotaDaily = mAccountInfo.getAnyTimeQuotaDailyMb();
    for (DailyVolumeUsage volumeUsage : usage) {
        // Get values from array
        Long anytime = (volumeUsage.anytime / MB);
        Long upload = (volumeUsage.uploads / MB);
        // Take off upload usage
        Long anytimeUsage = anytime - upload;
        Long uploadUsage = upload;
        // Calculate accumalitive values
        anytimeDailyAccum = anytimeDailyAccum + anytimeUsage;
        uploadDailyAccum = uploadDailyAccum + uploadUsage;
        quotaDailyAccum = quotaDailyAccum + quotaDaily;
        // Calculate stacked values
        long anytimeStacked = anytimeDailyAccum;
        long uploadStacked = anytimeDailyAccum + uploadDailyAccum;
        // Add current cursor values to data series
        anytimeSeries.add(anytimeStacked);
        uploadSeries.add(uploadStacked);
        anytimeQuotaSeries.add(quotaDailyAccum);
        // Set max data usage for rendering graph
        if (max <= uploadDailyAccum) {
            max = uploadDailyAccum * 1.05;
        }
        if (max <= quotaDailyAccum) {
            max = quotaDailyAccum * 1.05;
        }
    }
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(uploadSeries.toXYSeries());
    dataset.addSeries(anytimeSeries.toXYSeries());
    dataset.addSeries(anytimeQuotaSeries.toXYSeries());
    return dataset;
}

public void addXYSeries(XYMultipleSeriesDataset dataset, String[] titles, List<double[]> xValues, List<double[]> yValues, int scale) {
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        XYSeries series = new XYSeries(titles[i], scale);
        double[] xV = xValues.get(i);
        double[] yV = yValues.get(i);
        int seriesLength = xV.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(xV[k], yV[k]);
        }
        dataset.addSeries(series);
    }
}

/**
   * prepares an intent for starting the graph activity
   *
   * @return: the intent or null if nothing to display
   */
public Intent getIntent() {
    XYMultipleSeriesDataset dataset = getDataset();
    if (dataset == null) {
        return null;
    }
    XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
    renderer.setAxisTitleTextSize(16);
    renderer.setChartTitleTextSize(20);
    renderer.setLabelsTextSize(15);
    renderer.setLegendTextSize(15);
    renderer.setPointSize(5f);
    renderer.setMargins(new int[] { 20, 50, 15, 20 });
    XYSeriesRenderer seriesOne = new XYSeriesRenderer();
    seriesOne.setColor(Color.MAGENTA);
    seriesOne.setPointStyle(PointStyle.CIRCLE);
    renderer.addSeriesRenderer(seriesOne);
    XYSeriesRenderer seriesTwo = new XYSeriesRenderer();
    seriesTwo.setColor(Color.GREEN);
    seriesTwo.setPointStyle(PointStyle.TRIANGLE);
    renderer.addSeriesRenderer(seriesTwo);
    renderer.setChartTitle(ctxt.getString(R.string.graph_title));
    renderer.setXTitle("");
    renderer.setYTitle("mmHg");
    renderer.setShowGridX(true);
    renderer.setYLabelsAlign(Paint.Align.RIGHT);
    renderer.setYAxisMax(getYDataMax(dataset) + 10);
    renderer.setYAxisMin(getYDataMin(dataset) - 10);
    return ChartFactory.getTimeChartIntent(ctxt, getDataset(), renderer, "MM/dd/yyyy", ctxt.getString(R.string.app_name));
}

public View getView(Context context, Map<String, BarChartModel> treasuryChartData) {
    // if there is no data chart then the application has to generate it
    if (BarChartModel.hasNoChart(treasuryChartData)) {
        setGeneratedDataTreasuryChart(treasuryChartData);
    }
    String[] months = treasuryChartData.get(SETTLED_GRAPH_ID).getMonths();
    double[] valuesSettled = treasuryChartData.get(SETTLED_GRAPH_ID).getValues();
    CategorySeries seriesSettled = new CategorySeries(context.getResources().getString(R.string.dashboard_legend_settled));
    for (int i = 0; i < valuesSettled.length; i++) {
        seriesSettled.add(valuesSettled[i]);
    }
    double[] valuesOnTime = treasuryChartData.get(ONTIME_GRAPH_ID).getValues();
    CategorySeries serieOnTime = new CategorySeries(context.getResources().getString(R.string.dashboard_legend_onTime));
    for (int i = 0; i < valuesOnTime.length; i++) {
        serieOnTime.add(valuesOnTime[i]);
    }
    double[] valuesOverdue = treasuryChartData.get(OVERDUE_GRAPH_ID).getValues();
    CategorySeries seriesOverdue = new CategorySeries(context.getResources().getString(R.string.dashboard_legend_overdue));
    for (int i = 0; i < valuesOverdue.length; i++) {
        seriesOverdue.add(valuesOverdue[i]);
    }
    XYMultipleSeriesDataset dataSet = new XYMultipleSeriesDataset();
    dataSet.addSeries(0, seriesSettled.toXYSeries());
    dataSet.addSeries(1, serieOnTime.toXYSeries());
    dataSet.addSeries(2, seriesOverdue.toXYSeries());
    XYSeriesRenderer rendererReceived = new XYSeriesRenderer();
    rendererReceived.setColor(context.getResources().getColor(R.color.dashboard_green_color));
    XYSeriesRenderer rendererWithIn = new XYSeriesRenderer();
    rendererWithIn.setColor(context.getResources().getColor(R.color.dashboard_white_color));
    XYSeriesRenderer rendererLiquided = new XYSeriesRenderer();
    rendererLiquided.setColor(context.getResources().getColor(R.color.dashboard_red_color));
    int width = InvoiceXpress.getInstance().getScreenWidth((Activity) context);
    int height = InvoiceXpress.getInstance().getScreenHeight((Activity) context);
    BarChartInvoiceXpressRenderer multipleRenderer = new BarChartInvoiceXpressRenderer(context, width, height, valuesSettled, valuesOnTime, valuesOverdue);
    multipleRenderer.addSeriesRenderer(rendererReceived);
    multipleRenderer.addSeriesRenderer(rendererWithIn);
    multipleRenderer.addSeriesRenderer(rendererLiquided);
    multipleRenderer.setXAxisMax(months.length);
    for (int i = 0; i < months.length; i++) {
        multipleRenderer.addXTextLabel(i + 1, months[i]);
    }
    XYChart chart = new BarChartInvoiceXpress(context, dataSet, multipleRenderer, Type.DEFAULT);
    return new GraphicalView(context, chart);
}

/**
   * Creates a combined XY chart view.
   * 
   * @param context the context
   * @param dataset the multiple series dataset (cannot be null)
   * @param renderer the multiple series renderer (cannot be null)
   * @param types the chart types (cannot be null)
   * @return a combined XY chart graphical view
   * @throws IllegalArgumentException if dataset is null or renderer is null or
   *           if a dataset number of items is different than the number of
   *           series renderers or number of chart types
   */
public static final GraphicalView getCombinedXYChartView(Context context, XYMultipleSeriesDataset dataset, XYMultipleSeriesRenderer renderer, String[] types) {
    if (dataset == null || renderer == null || types == null || dataset.getSeriesCount() != types.length) {
        throw new IllegalArgumentException("Dataset, renderer and types should be not null and the datasets series count should be equal to the types length");
    }
    checkParameters(dataset, renderer);
    CombinedXYChart chart = new CombinedXYChart(dataset, renderer, types);
    return new GraphicalView(context, chart);
}

public View getView(Context context) {
    long minTime = System.currentTimeMillis() + 60 * 60 * 1000;
    long maxTime = 0;
    if (listpayloads.size() < 1)
        return null;
    if (Math.min(2, listfields.size()) == 0)
        return null;
    int differentFields = 0;
    int tempLoc = -1;
    for (int i = 0; i < listfields.size(); i++) {
        if (isTemperature(listfields.get(i))) {
            if (tempLoc < 0) {
                tempLoc = i;
                differentFields++;
            }
        } else
            differentFields++;
    }
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    XYMultipleSeriesRenderer mrend = new XYMultipleSeriesRenderer(Math.min(2, differentFields));
    int cnt = 0;
    for (int i = 0; i < listpayloads.size(); i++) {
        String call = listpayloads.get(i);
        int colour = _data.get(call).colour;
        for (int f = 0; f < listfields.size(); f++) {
            String field = listfields.get(f);
            double m = 1;
            double c = 0;
            if (_data.containsKey(call)) {
                int findex = 0;
                if (_data.get(call).telemetryConfig != null) {
                    findex = _data.get(call).telemetryConfig.getIndex(field);
                    if (findex >= 0) {
                        m = _data.get(call).telemetryConfig.getFieldScale(findex);
                        c = _data.get(call).telemetryConfig.getFieldOffset(findex);
                    }
                }
                if (findex >= 0) {
                    TreeMap<Long, Telemetry_string> sen = _data.get(call).data;
                    if (sen.size() > 1) {
                        int axis = 0;
                        if (!isTemperature(listfields.get(f))) {
                            if (tempLoc == 0)
                                axis = 1;
                            else
                                axis = f;
                        } else
                            axis = tempLoc;
                        XYSeries series = new XYSeries(_data.get(call).callsign + " - " + field, axis);
                        for (TreeMap.Entry<Long, Telemetry_string> entry : sen.entrySet()) {
                            if (field == "altitude") {
                                if (entry.getValue().coords.alt_valid)
                                    series.add(entry.getKey(), (int) entry.getValue().coords.altitude);
                            } else {
                                if (entry.getValue().getExtraFieldExists(findex))
                                    series.add(entry.getKey(), m * entry.getValue().getExtraFields(findex) + c);
                            }
                        }
                        if (series.getMinX() < minTime)
                            minTime = (long) series.getMinX();
                        if (series.getMaxX() > maxTime)
                            maxTime = (long) series.getMaxX();
                        dataset.addSeries(series);
                        //else
                        //	dataset.addSeries(f,series);
                        XYSeriesRenderer renderer = new XYSeriesRenderer();
                        renderer.setColor(colour);
                        renderer.setLineWidth(4);
                        //stroke style
                        mrend.addSeriesRenderer(renderer);
                        cnt++;
                    }
                }
            }
            float lasthsv[] = new float[3];
            Color.colorToHSV(colour, lasthsv);
            lasthsv[0] = (lasthsv[0] + (26)) % 360;
            colour = Color.HSVToColor(lasthsv);
        }
    }
    if (cnt == 0)
        return null;
    //mrend.addXTextLabel(System.currentTimeMillis(), "custom label");
    int steps = 13;
    long inc = (maxTime - minTime) / steps;
    for (int i = 0; i < steps; i++) {
        Date dt = new Date(minTime + i * inc);
        SimpleDateFormat dtf = new SimpleDateFormat("HH:mm");
        mrend.addXTextLabel(minTime + i * inc, dtf.format(dt));
    }
    //mrend.setChartTitle("Altitude Plot");
    mrend.setYTitle("Altitude (m)", 0);
    if (Math.min(2, differentFields) > 1) {
        //mrend.addYTextLabel(10, "New Test", 1);
        //mrend.setYTitle("Hours", 1);
        mrend.setYAxisAlign(Align.RIGHT, 1);
    }
    mrend.setShowGrid(true);
    for (int i = 0; i < Math.min(2, differentFields); i++) {
        mrend.setXAxisMax(maxTime, i);
        mrend.setXAxisMin(minTime, i);
    }
    mrend.setYLabelsAngle(270);
    mrend.setXLabels(0);
    return ChartFactory.getLineChartView(context, dataset, mrend);
}

/**
	 * Builds an XY multiple dataset using the provided values.
	 *
	 * @param titles the series titles
	 * @param xValues the values for the X axis
	 * @param yValues the values for the Y axis
	 * @return the XY multiple dataset
	 */
protected XYMultipleSeriesDataset buildDataset(String[] titles, List<double[]> xValues, List<double[]> yValues) {
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        XYSeries series = new XYSeries(titles[i]);
        double[] xV = xValues.get(i);
        double[] yV = yValues.get(i);
        int seriesLength = xV.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(xV[k], yV[k]);
        }
        dataset.addSeries(series);
    }
    return dataset;
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    // keep main display on?
    if (MainActivity.prefs.getBoolean("keep_screen_on", false)) {
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    }
    // prevent activity from falling asleep
    PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
    wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, getString(R.string.app_name));
    wakeLock.acquire();
    // set up action bar
    ActionBar actionBar = getActionBar();
    if (actionBar != null) {
        actionBar.setDisplayShowTitleEnabled(true);
    }
    setTitle(R.string.chart);
    /* get PIDs to be shown */
    int positions[] = getIntent().getIntArrayExtra(POSITIONS);
    // set up overall chart properties
    sensorData = new XYMultipleSeriesDataset();
    renderer = new XYMultipleSeriesRenderer(positions.length);
    chartView = ChartFactory.getTimeChartView(this, sensorData, renderer, "H:mm:ss");
    // set up global renderer
    renderer.setXTitle(getString(R.string.time));
    renderer.setXLabels(5);
    renderer.setYLabels(5);
    renderer.setGridColor(Color.DKGRAY);
    renderer.setShowGrid(true);
    renderer.setFitLegend(true);
    renderer.setClickEnabled(false);
    // set up chart data
    setUpChartData(positions);
    // make chart visible
    setContentView(chartView);
    // limit selected PIDs to selection
    MainActivity.setFixedPids(pidNumbers);
    // if auto hiding selected ...
    if (MainActivity.prefs.getBoolean(MainActivity.PREF_AUTOHIDE, false)) {
        // get autohide timeout [s]
        int timeout = Integer.valueOf(MainActivity.prefs.getString(MainActivity.PREF_AUTOHIDE_DELAY, "15"));
        // auto hide toolbar
        toolBarHider = new AutoHider(this, mHandler, MainActivity.MESSAGE_TOOLBAR_VISIBLE, timeout * 1000);
        toolBarHider.start(1000);
        // wake up on touch
        chartView.setOnTouchListener(toolBarHider);
    }
}

private void showChart(XYSeries series) {
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(series);
    XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
    XYSeriesRenderer seriesRenderer = new XYSeriesRenderer();
    seriesRenderer.setColor(0xFFFF9C24);
    renderer.addSeriesRenderer(seriesRenderer);
    renderer.setShowLegend(false);
    renderer.setAxesColor(0x66666666);
    PreferencesProvider prefs = PreferencesProvider.getInstance(this);
    String format = prefs.getString(PreferencesProvider.DATE, "MM/dd/yy");
    startActivity(ChartFactory.getTimeChartIntent(ChartsView.this, dataset, renderer, format));
}

public void addXYSeries(XYMultipleSeriesDataset dataset, String[] titles, List<double[]> xValues, List<double[]> yValues, int scale) {
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        XYSeries series = new XYSeries(titles[i], scale);
        double[] xV = xValues.get(i);
        double[] yV = yValues.get(i);
        int seriesLength = xV.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(xV[k], yV[k]);
        }
        dataset.addSeries(series);
    }
}

public void addXYSeries(XYMultipleSeriesDataset dataset, String[] titles, List<double[]> xValues, List<double[]> yValues, int scale) {
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        XYSeries series = new XYSeries(titles[i], scale);
        double[] xV = xValues.get(i);
        double[] yV = yValues.get(i);
        int seriesLength = xV.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(xV[k], yV[k]);
        }
        dataset.addSeries(series);
    }
}

protected XYMultipleSeriesDataset buildBarDataset(String[] titles, List<double[]> values) {
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        CategorySeries series = new CategorySeries(titles[i]);
        double[] v = values.get(i);
        int seriesLength = v.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(v[k]);
        }
        dataset.addSeries(series.toXYSeries());
    }
    return dataset;
}

/**
     * Initialize ECG chart.
     */
private void init() {
    this.mECGList = new ArrayList<>();
    this.mECGList.add(new XYSeries(TITLES[0]));
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addAllSeries(this.mECGList);
    this.mXYMultipleSeriesRenderer = buildRenderer();
    mLineChart = new LineChart(dataset, mXYMultipleSeriesRenderer);
    mGraphicalView = new GraphicalView(getActivity(), mLineChart);
}

/**
   * Creates a combined XY chart view.
   * 
   * @param context the context
   * @param dataset the multiple series dataset (cannot be null)
   * @param renderer the multiple series renderer (cannot be null)
   * @param types the chart types (cannot be null)
   * @return a combined XY chart graphical view
   * @throws IllegalArgumentException if dataset is null or renderer is null or
   *           if a dataset number of items is different than the number of
   *           series renderers or number of chart types
   */
public static final GraphicalView getCombinedXYChartView(Context context, XYMultipleSeriesDataset dataset, XYMultipleSeriesRenderer renderer, String[] types) {
    if (dataset == null || renderer == null || types == null || dataset.getSeriesCount() != types.length) {
        throw new IllegalArgumentException("Dataset, renderer and types should be not null and the datasets series count should be equal to the types length");
    }
    checkParameters(dataset, renderer);
    CombinedXYChart chart = new CombinedXYChart(dataset, renderer, types);
    return new GraphicalView(context, chart);
}

private void openChart() {
    Runnable runnable = new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                URL url = new URL("http://58.27.132.54:443/health/getGraphJSON?");
                HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
                int resCode = urlConnection.getResponseCode();
                if (resCode == 200) {
                    InputStream is = new BufferedInputStream(urlConnection.getInputStream());
                    BufferedReader reader = new BufferedReader(new InputStreamReader(is, "iso-8859-1"), 8);
                    StringBuilder sb = new StringBuilder();
                    String line = null;
                    String result = "";
                    while ((line = reader.readLine()) != null) {
                        sb.append(line + "\n");
                    }
                    is.close();
                    result = sb.toString();
                    JSONArray jArray = new JSONArray(result);
                    for (int i = 0; i < jArray.length(); i++) {
                        JSONObject c = jArray.getJSONObject(i);
                        // Storing each json item in variable
                        Integer ExerciseName = c.getInt("CaloriesDiff");
                        calBurntArrayList.add(ExerciseName);
                    // Toast.makeText(getApplicationContext(),
                    // ExerciseName+" ", Toast.LENGTH_LONG).show();
                    }
                } else
                    resCode = -1;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };
    runnable.run();
    double sumCal = 0;
    ArrayList<Integer> calRight = new ArrayList<Integer>();
    for (int i = calBurntArrayList.size() - 1; i >= 0; i--) {
        calRight.add(calBurntArrayList.get(i).intValue());
    }
    for (int j = 0; j < calRight.size(); j++) {
        daily[j] = calRight.get(j).intValue();
        sumCal = daily[j] + sumCal;
    }
    sumCal = sumCal / 15;
    int[] x = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
    /*
		 * int[] daily = { 1714, 1331, 1902, 1424, 1815, 1857, 1508, 1804, 1818,
		 * 1550, 1464, 1983, 1497, 1479, 1869, 1978 };
		 */
    Runnable runnable2 = new Runnable() {

        @Override
        public void run() {
            try {
                URL url = new URL("http://58.27.132.54:443/health/getUserJSON?");
                HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
                int resCode = urlConnection.getResponseCode();
                if (resCode == 200) {
                    InputStream is = new BufferedInputStream(urlConnection.getInputStream());
                    BufferedReader reader = new BufferedReader(new InputStreamReader(is, "iso-8859-1"), 8);
                    StringBuilder sb = new StringBuilder();
                    String line = null;
                    String result = "";
                    while ((line = reader.readLine()) != null) {
                        sb.append(line + "\n");
                    }
                    is.close();
                    result = sb.toString();
                    JSONArray jArray = new JSONArray(result);
                    for (int i = 0; i < jArray.length(); i++) {
                        JSONObject c = jArray.getJSONObject(i);
                        // Storing each json item in variable
                        h = c.getDouble("Height");
                        W = c.getDouble("Weight");
                        GW = c.getDouble("WeightGoal");
                        duration = c.getInt("GoalWeightDuration");
                        age = c.getInt("Age");
                    }
                } else
                    resCode = -1;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };
    runnable2.run();
    h = h * 100;
    double calories = ((10 * (W)) + (6.5 * h) - (5 * age) * 1.55);
    double sum = GW - W;
    double cal = Math.abs(sum) / (duration / 7) * 2;
    calories = calories - cal;
    int[] goal = new int[15];
    int[] goal1 = new int[15];
    for (int i = 0; i < 15; i++) {
        goal[i] = (int) calories;
        goal1[i] = (int) sumCal;
    }
    /*= { 1672, 1672, 1672, 1672, 1672, 1672, 1672, 1672, 1672,
				1672, 1672, 1672, 1672, 1672, 1672, 1672 };
		
		int[] goal1 = { 1687, 1687, 1687, 1687, 1687, 1687, 1687, 1687, 1687,
				1687, 1687, 1687, 1687, 1687, 1687, 1687 };
		*/
    /// Creating an XYSeries for Income
    // CategorySeries incomeSeries = new CategorySeries("Income");
    XYSeries dailySeries = new XYSeries("Daily");
    // Creating an XYSeries for Income
    XYSeries goalSeries = new XYSeries("Goal");
    // Adding data to Income and Expense Series
    XYSeries avgSeries = new XYSeries("Avg");
    // Adding data to Income and Expense Series
    for (int i = 0; i < x.length; i++) {
        dailySeries.add(i, daily[i]);
        goalSeries.add(i, goal[i]);
        avgSeries.add(i, goal1[i]);
    }
    // Creating a dataset to hold each series
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    // Adding Income Series to the dataset
    dataset.addSeries(dailySeries);
    // Adding Expense Series to dataset
    dataset.addSeries(goalSeries);
    dataset.addSeries(avgSeries);
    // Creating XYSeriesRenderer to customize incomeSeries
    XYSeriesRenderer incomeRenderer = new XYSeriesRenderer();
    incomeRenderer.setColor(Color.rgb(130, 130, 230));
    incomeRenderer.setFillPoints(true);
    incomeRenderer.setLineWidth(2);
    incomeRenderer.setDisplayChartValues(true);
    // Creating XYSeriesRenderer to customize expenseSeries
    XYSeriesRenderer expenseRenderer = new XYSeriesRenderer();
    expenseRenderer.setColor(Color.rgb(220, 80, 80));
    expenseRenderer.setFillPoints(true);
    expenseRenderer.setLineWidth(2);
    expenseRenderer.setDisplayChartValues(true);
    // Creating XYSeriesRenderer to customize expenseSeries
    XYSeriesRenderer goalRenderer = new XYSeriesRenderer();
    goalRenderer.setColor(Color.rgb(200, 100, 150));
    goalRenderer.setFillPoints(true);
    goalRenderer.setLineWidth(2);
    goalRenderer.setDisplayChartValues(true);
    // Creating a XYMultipleSeriesRenderer to customize the whole chart
    XYMultipleSeriesRenderer multiRenderer = new XYMultipleSeriesRenderer();
    multiRenderer.setXLabels(0);
    multiRenderer.setChartTitle("Daily Calories vs Goal Calories");
    multiRenderer.setXTitle("June 2013");
    multiRenderer.setYTitle("Calories");
    multiRenderer.setZoomButtonsVisible(true);
    for (int i = 0; i < x.length; i++) {
        multiRenderer.addXTextLabel(i, mMonth[i]);
    }
    // Adding incomeRenderer and expenseRenderer to multipleRenderer
    // Note: The order of adding dataseries to dataset and renderers to
    // multipleRenderer
    // should be same
    multiRenderer.addSeriesRenderer(incomeRenderer);
    multiRenderer.addSeriesRenderer(expenseRenderer);
    multiRenderer.addSeriesRenderer(goalRenderer);
    // Creating an intent to plot bar chart using dataset and
    // multipleRenderer
    Intent intent = ChartFactory.getLineChartIntent(getBaseContext(), dataset, multiRenderer);
    // Start Activity
    startActivity(intent);
}

private void displayLineChart(double[] myTimes, double[] myRates) {
    // Creating an  XYSeries for Heart Rate
    XYSeries hrSeries = new XYSeries("Heart Rate");
    // Adding data to  hrSeries
    for (int i = 0; i < myTimes.length; i++) {
        hrSeries.add(myTimes[i], myRates[i]);
    }
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(hrSeries);
    XYSeriesRenderer hrRenderer = new XYSeriesRenderer();
    hrRenderer.setColor(Color.GREEN);
    hrRenderer.setPointStyle(PointStyle.DIAMOND);
    hrRenderer.setFillPoints(true);
    hrRenderer.setLineWidth(2);
    hrRenderer.setDisplayChartValues(true);
    XYMultipleSeriesRenderer multiRenderer = new XYMultipleSeriesRenderer();
    multiRenderer.setXLabels(0);
    multiRenderer.setChartTitle("Heart Rate vs Time");
    multiRenderer.setXTitle("Timestamps (s)");
    multiRenderer.setYTitle("Heart Rate");
    multiRenderer.setApplyBackgroundColor(true);
    multiRenderer.setBackgroundColor(Color.BLACK);
    multiRenderer.setZoomButtonsVisible(true);
    for (int i = 0; i < myTimes.length; i++) {
        String label;
        label = String.valueOf(myTimes[i]);
        multiRenderer.addXTextLabel(i + 1, label);
    }
    multiRenderer.addSeriesRenderer(hrRenderer);
    Intent intent = ChartFactory.getLineChartIntent(getBaseContext(), dataset, multiRenderer);
    startActivity(intent);
}

/**
   * Builds an XY multiple dataset using the provided values.
   * 
   * @param titles the series titles
   * @param xValues the values for the X axis
   * @param yValues the values for the Y axis
   * @return the XY multiple dataset
   */
protected XYMultipleSeriesDataset buildDataset(String[] titles, List<double[]> xValues, List<double[]> yValues) {
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        XYSeries series = new XYSeries(titles[i]);
        double[] xV = xValues.get(i);
        double[] yV = yValues.get(i);
        int seriesLength = xV.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(xV[k], yV[k]);
        }
        dataset.addSeries(series);
    }
    return dataset;
}

private void setupChart(List<MtGoxTickerData> dataList) {
    dataset = new XYMultipleSeriesDataset();
    renderer = initChart();
    XYSeries highSeries = addSeries(getString(R.string.high), Color.parseColor("#00CC00"), false);
    XYSeries lowSeries = addSeries(getString(R.string.low), Color.parseColor("#CC0000"), false);
    XYSeries sellSeries = addSeries(getString(R.string.sell), Color.parseColor("#AAFFAA"), false);
    XYSeries buySeries = addSeries(getString(R.string.buy), Color.parseColor("#FFAAAA"), false);
    XYSeries lastSeries = addSeries(getString(R.string.last), Color.WHITE, true);
    for (MtGoxTickerData data : dataList) {
        //Log.d("Graphdata", data.toString());
        addDataToSeriesIfNotNull(highSeries, data.getTimestamp().getTime(), data.getHigh());
        addDataToSeriesIfNotNull(lowSeries, data.getTimestamp().getTime(), data.getLow());
        addDataToSeriesIfNotNull(sellSeries, data.getTimestamp().getTime(), data.getSell());
        addDataToSeriesIfNotNull(buySeries, data.getTimestamp().getTime(), data.getBuy());
        addDataToSeriesIfNotNull(lastSeries, data.getTimestamp().getTime(), data.getLast());
    }
}

private void openChart() {
    XYSeries durationSeries = new XYSeries("Duration of travel");
    int timeLength = trafficStatList.size();
    for (int i = 0; i < timeLength; i++) {
        durationSeries.add((i + 1), trafficStatList.get(i).getTravelTime());
    }
    XYSeries speedSeries = new XYSeries("Speed");
    for (int i = 0; i < timeLength; i++) {
        speedSeries.add((i + 1), trafficStatList.get(i).getSpeed());
    }
    //Collects all series and adds them under one object here called data
    XYMultipleSeriesDataset data = new XYMultipleSeriesDataset();
    data.addSeries(durationSeries);
    data.addSeries(speedSeries);
    //Gives the Bar it's property
    XYSeriesRenderer durRenderer = new XYSeriesRenderer();
    durRenderer.setColor(Color.GREEN);
    durRenderer.setDisplayChartValues(true);
    durRenderer.setChartValuesTextAlign(Paint.Align.CENTER);
    durRenderer.setChartValuesTextSize(15);
    XYSeriesRenderer speedRenderer = new XYSeriesRenderer();
    speedRenderer.setColor(Color.CYAN);
    speedRenderer.setDisplayChartValues(true);
    speedRenderer.setChartValuesTextAlign(Paint.Align.CENTER);
    speedRenderer.setChartValuesTextSize(15);
    XYMultipleSeriesRenderer mRender = new XYMultipleSeriesRenderer();
    mRender.setBarSpacing(1);
    mRender.addSeriesRenderer(durRenderer);
    mRender.addSeriesRenderer(speedRenderer);
    mRender.setChartTitle("Travel Time and Speed");
    mRender.setXTitle("Departure Time");
    mRender.setYTitle("Duration and Speed");
    mRender.setZoomButtonsVisible(true);
    mRender.setLabelsTextSize(20);
    mRender.setLegendTextSize(15);
    mRender.setChartTitleTextSize(28);
    mRender.setAxisTitleTextSize(25);
    mRender.setXAxisMin(trafficStatList.get(1).getHour());
    mRender.setXAxisMax(trafficStatList.size());
    for (int i = 0; i < timeLength; i++) {
        mRender.addTextLabel(i + 1, String.valueOf((int) trafficStatList.get(i).getHour() + ":" + (int) trafficStatList.get(i).getMinutes()));
    }
    mRender.setXLabelsAlign(CENTER);
    mRender.setXLabels(0);
    // Getting a reference to LinearLayout of the MainActivity Layout
    LinearLayout chartContainer = (LinearLayout) findViewById(R.id.chart_container);
    // Creating a Time Chart
    mChart = (GraphicalView) ChartFactory.getBarChartView(getBaseContext(), data, mRender, BarChart.Type.DEFAULT);
    //return intent;
    mRender.setClickEnabled(true);
    mRender.setSelectableBuffer(10);
    mChart.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            SeriesSelection seriesSelection = mChart.getCurrentSeriesAndPoint();
            if (seriesSelection != null) {
                int seriesIndex = seriesSelection.getSeriesIndex();
                String selectedSeries = "Duration";
                if (seriesIndex == 0)
                    selectedSeries = "Duration";
                else
                    selectedSeries = "Speed";
            }
        }
    });
    chartContainer.addView(mChart);
}

/**
   * Builds an XY multiple dataset using the provided values.
   * @param titles the series titles
   * @param xValues the values for the X axis
   * @param yValues the values for the Y axis
   * @return the XY multiple dataset
   */
protected XYMultipleSeriesDataset buildDataset(String[] titles, List<double[]> xValues, List<double[]> yValues) {
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        XYSeries series = new XYSeries(titles[i]);
        double[] xV = xValues.get(i);
        double[] yV = yValues.get(i);
        int seriesLength = xV.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(xV[k], yV[k]);
        }
        dataset.addSeries(series);
    }
    return dataset;
}

public Intent initGraph() {
    ArrayList<Double> storedWeights = new ArrayList<Double>();
    ArrayList<Long> storedDates = new ArrayList<Long>();
    BufferedReader read = null;
    String newTitle = profile.getUsername() + "_progress.txt";
    //long offset = 1000*60*60*4;
    long offset = 0;
    try {
        read = new BufferedReader(new InputStreamReader(openFileInput(newTitle)));
        while (read.ready()) {
            storedWeights.add(Double.parseDouble(read.readLine()));
            storedDates.add(Long.parseLong(read.readLine()));
        }
        read.close();
        read = null;
    } catch (Exception e) {
        Toast.makeText(this, "Progress Reading Failed", Toast.LENGTH_SHORT).show();
        e.printStackTrace();
    }
    Date[] x = new Date[storedDates.size()];
    Double[] y = new Double[storedWeights.size()];
    for (int i = 0; i < storedDates.size(); i++) {
        x[i] = new Date(storedDates.get(i) - offset);
        y[i] = storedWeights.get(i);
    }
    double minWeight = y[0];
    double maxWeight = y[0];
    for (int i = 0; i < storedDates.size(); i++) {
        if (y[i] < minWeight) {
            minWeight = y[i];
        }
        if (y[i] > maxWeight) {
            maxWeight = y[i];
        }
    }
    if (minWeight > profile.getTargetWeight()) {
        minWeight = profile.getTargetWeight();
    }
    if (maxWeight < profile.getTargetWeight()) {
        maxWeight = profile.getTargetWeight();
    }
    TimeSeries series = new TimeSeries("Weight (lbs)");
    for (int i = 0; i < x.length; i++) {
        series.add(x[i], y[i]);
    }
    TimeSeries target = new TimeSeries("Target Weight");
    target.add(x[0], profile.getTargetWeight());
    target.add(x[(x.length - 1)], profile.getTargetWeight());
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(series);
    dataset.addSeries(target);
    XYMultipleSeriesRenderer mRenderer = new XYMultipleSeriesRenderer();
    XYSeriesRenderer renderer = new XYSeriesRenderer();
    renderer.setColor(Color.YELLOW);
    mRenderer.addSeriesRenderer(renderer);
    XYSeriesRenderer renderer2 = new XYSeriesRenderer();
    renderer2.setColor(Color.RED);
    mRenderer.addSeriesRenderer(renderer2);
    mRenderer.setXTitle("Date");
    mRenderer.setYTitle("Weight");
    if ((minWeight - 30) < 0) {
        minWeight = 30;
    }
    mRenderer.setYAxisMin(minWeight - 30);
    mRenderer.setYAxisMax(maxWeight + 30);
    Intent lineIntent = ChartFactory.getTimeChartIntent(this, dataset, mRenderer, "Weight Loss Progress");
    return lineIntent;
}

@Override
protected AbstractChart buildChart() {
    Log.d(TAG, "Attempting to build chart.");
    if (mChart != null) {
        Log.w(TAG, "Attempt to build chart when chart already exists.");
        return mChart;
    }
    mDataset = new XYMultipleSeriesDataset();
    mRenderer = new XYMultipleSeriesRenderer();
    // Set initial framing for renderer.
    mRenderer.setYAxisMin(0);
    // Referencing SettingsActivity.MAX_ALARM_SENSITIVITY causes errors in ADT.
    if (isInEditMode()) {
        mRenderer.setYAxisMax(1.0f);
    } else {
        mRenderer.setYAxisMax(SettingsActivity.MAX_ALARM_SENSITIVITY);
    }
    mRenderer.setXAxisMin(System.currentTimeMillis());
    mRenderer.setXAxisMax(System.currentTimeMillis());
    mRenderer.setPanEnabled(false, false);
    mRenderer.setZoomEnabled(false, false);
    TimeChart timeChart = new TimeChart(mDataset, mRenderer);
    timeChart.setDateFormat("h:mm:ss");
    mChart = timeChart;
    return mChart;
}

public void addXYSeries(XYMultipleSeriesDataset dataset, String[] titles, List<double[]> xValues, List<double[]> yValues, int scale) {
    int length = titles.length;
    for (int i = 0; i < length; i++) {
        XYSeries series = new XYSeries(titles[i], scale);
        double[] xV = xValues.get(i);
        double[] yV = yValues.get(i);
        int seriesLength = xV.length;
        for (int k = 0; k < seriesLength; k++) {
            series.add(xV[k], yV[k]);
        }
        dataset.addSeries(series);
    }
}

private static void a(XYMultipleSeriesDataset xymultipleseriesdataset, XYMultipleSeriesRenderer xymultipleseriesrenderer) {
    if (xymultipleseriesdataset == null || xymultipleseriesrenderer == null || xymultipleseriesdataset.getSeriesCount() != xymultipleseriesrenderer.getSeriesRendererCount()) {
        throw new IllegalArgumentException("Dataset and renderer should be not null and should have the same number of series");
    } else {
        return;
    }
}

private void drawChart() {
    mRenderer = new XYMultipleSeriesRenderer();
    mDataset = new XYMultipleSeriesDataset();
    XYSeriesRenderer renderer = new XYSeriesRenderer();
    renderer.setLineWidth(5);
    renderer.setColor(Color.parseColor("#0099cc"));
    renderer.setDisplayBoundingPoints(true);
    renderer.setPointStyle(PointStyle.CIRCLE);
    renderer.setPointStrokeWidth(10);
    //FillOutsideLine fillOutsideLine = new FillOutsideLine(Type.BOUNDS_ALL);
    //fillOutsideLine.setColor(Color.parseColor("#0099cc")); 
    //renderer.addFillOutsideLine(fillOutsideLine); 
    //mRenderer.setChartTitle("Battery Level (%)");
    mRenderer.setChartTitleTextSize(30f);
    mRenderer.setLabelsTextSize(20f);
    mRenderer.addSeriesRenderer(renderer);
    mRenderer.setMarginsColor(Color.argb(0x00, 0xff, 0x00, 0x00));
    mRenderer.setPanEnabled(true, false);
    mRenderer.setZoomEnabled(false, false);
    mRenderer.setYAxisMax(DeviceUtils.getBatteryScale(getActivity()));
    mRenderer.setYAxisMin(0);
    //mRenderer.setShowGrid(true);
    mRenderer.setGridColor(Color.GRAY);
    mRenderer.setClickEnabled(false);
    TimeSeries series = new TimeSeries("");
    /*      long value = new Date().getTime() - 3 * TimeChart.DAY;
        for (int i = 0; i < 5; i++) {
			series.add(new Date(value + i * TimeChart.DAY / 4), i);
		}*/
    List<BatteryTrace> traces = BatteryTrace.getClosestTraceData(getActivity().getContentResolver(), LIMIT_DATE_SHOW);
    boolean chartVisible = traces.size() >= MINIMUM_VALUE_TO_SHOW_CHART;
    if (chartVisible) {
        Calendar panMinimumX = Calendar.getInstance();
        panMinimumX.set(Calendar.HOUR_OF_DAY, traces.get(0).hour);
        panMinimumX.set(Calendar.MINUTE, traces.get(0).minutes);
        Calendar panMaximumX = Calendar.getInstance();
        panMaximumX.set(Calendar.HOUR_OF_DAY, traces.get(traces.size() - 1).hour);
        panMaximumX.set(Calendar.MINUTE, traces.get(traces.size() - 1).minutes);
        //mRenderer.setPanLimits(new double[] {panMinimumX.getTimeInMillis(), panMaximumX.getTimeInMillis() * 2, 0, 0});
        for (BatteryTrace b : traces) {
            //System.out.println(b.toString()); 
            Calendar c = Calendar.getInstance();
            c.set(Calendar.HOUR_OF_DAY, b.hour);
            c.set(Calendar.MINUTE, b.minutes);
            series.add(c.getTime(), b.level);
        }
        mDataset.addSeries(series);
        mChartView = ChartFactory.getTimeChartView(getActivity(), mDataset, mRenderer, "hh:mm aa");
    }
}

private static void checkParameters(XYMultipleSeriesDataset xymultipleseriesdataset, XYMultipleSeriesRenderer xymultipleseriesrenderer) {
    if (xymultipleseriesdataset == null || xymultipleseriesrenderer == null || xymultipleseriesdataset.getSeriesCount() != xymultipleseriesrenderer.getSeriesRendererCount())
        throw new IllegalArgumentException("Dataset and renderer should be not null and should have the same number of series");
    else
        return;
}

public void refreshView() {
    if (counterService == null) {
        TextView loadingText = new TextView(this);
        loadingText.setText("Waiting for profiler service...");
        loadingText.setGravity(Gravity.CENTER);
        setContentView(loadingText);
        return;
    }
    chartLayout = new LinearLayout(this);
    chartLayout.setOrientation(LinearLayout.VERTICAL);
    if (uid == SystemInfo.AID_ALL) {
        /* If we are reporting global power usage then just set noUidMask to 0 so
       * that all components get displayed.
       */
        noUidMask = 0;
    }
    components = 0;
    for (int i = 0; i < componentNames.length; i++) {
        if ((noUidMask & 1 << i) == 0) {
            components++;
        }
    }
    boolean showTotal = prefs.getBoolean("showTotalPower", false);
    collectors = new ValueCollector[(showTotal ? 1 : 0) + components];
    int pos = 0;
    for (int i = showTotal ? -1 : 0; i < componentNames.length; i++) {
        if (i != -1 && (noUidMask & 1 << i) != 0) {
            continue;
        }
        String name = i == -1 ? "Total" : componentNames[i];
        double mxPower = (i == -1 ? 2100.0 : componentsMaxPower[i]) * 1.05;
        XYSeries series = new XYSeries(name);
        XYMultipleSeriesDataset mseries = new XYMultipleSeriesDataset();
        mseries.addSeries(series);
        XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
        XYSeriesRenderer srenderer = new XYSeriesRenderer();
        renderer.setYAxisMin(0.0);
        renderer.setYAxisMax(mxPower);
        renderer.setYTitle(name + "(mW)");
        int clr = PowerPie.COLORS[(PowerPie.COLORS.length + i) % PowerPie.COLORS.length];
        srenderer.setColor(clr);
        srenderer.setFillBelowLine(true);
        srenderer.setFillBelowLineColor(((clr >> 1) & 0x7F7F7F) | (clr & 0xFF000000));
        renderer.addSeriesRenderer(srenderer);
        View chartView = new GraphicalView(this, new CubicLineChart(mseries, renderer, 0.5f));
        chartView.setMinimumHeight(100);
        chartLayout.addView(chartView);
        collectors[pos] = new ValueCollector(series, renderer, chartView, i);
        if (handler != null) {
            handler.post(collectors[pos]);
        }
        pos++;
    }
    /* We're giving 100 pixels per graph of vertical space for the chart view.
       If we don't specify a minimum height the chart view ends up having a
       height of 0 so this is important. */
    chartLayout.setMinimumHeight(100 * components);
    ScrollView scrollView = new ScrollView(this) {

        public boolean onInterceptTouchEvent(android.view.MotionEvent ev) {
            return true;
        }
    };
    scrollView.addView(chartLayout);
    scrollView.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
    setContentView(scrollView);
}

/**
   * Creates a combined XY chart view.
   * 
   * @param context the context
   * @param dataset the multiple series dataset (cannot be null)
   * @param renderer the multiple series renderer (cannot be null)
   * @param types the chart types (cannot be null)
   * @return a combined XY chart graphical view
   * @throws IllegalArgumentException if dataset is null or renderer is null or
   *           if a dataset number of items is different than the number of
   *           series renderers or number of chart types
   */
public static final GraphicalView getCombinedXYChartView(Context context, XYMultipleSeriesDataset dataset, XYMultipleSeriesRenderer renderer, String[] types) {
    if (dataset == null || renderer == null || types == null || dataset.getSeriesCount() != types.length) {
        throw new IllegalArgumentException("Dataset, renderer and types should be not null and the datasets series count should be equal to the types length");
    }
    checkParameters(dataset, renderer);
    CombinedXYChart chart = new CombinedXYChart(dataset, renderer, types);
    return new GraphicalView(context, chart);
}

private View createTempGraph() {
    // We start creating the XYSeries to plot the temperature
    XYSeries series = new XYSeries("London Temperature hourly");
    // We start filling the series
    int hour = 0;
    for (HourForecast hf : nextHourForecast) {
        series.add(hour++, hf.weather.temperature.getTemp());
    }
    // Now we create the renderer
    XYSeriesRenderer renderer = new XYSeriesRenderer();
    renderer.setLineWidth(2);
    renderer.setColor(Color.RED);
    // Include low and max value
    renderer.setDisplayBoundingPoints(true);
    // we add point markers
    renderer.setPointStyle(PointStyle.CIRCLE);
    renderer.setPointStrokeWidth(3);
    // Now we add our series
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(series);
    // Finaly we create the multiple series renderer to control the graph
    XYMultipleSeriesRenderer mRenderer = new XYMultipleSeriesRenderer();
    mRenderer.addSeriesRenderer(renderer);
    // We want to avoid black border
    // transparent margins
    mRenderer.setMarginsColor(Color.argb(0x00, 0xff, 0x00, 0x00));
    // Disable Pan on two axis
    mRenderer.setPanEnabled(false, false);
    mRenderer.setYAxisMax(35);
    mRenderer.setYAxisMin(0);
    // we show the grid
    mRenderer.setShowGrid(true);
    GraphicalView chartView = ChartFactory.getLineChartView(getActivity(), dataset, mRenderer);
    // Enable chart click
    mRenderer.setClickEnabled(true);
    chartView.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            applyAnim(v, createPressGraph());
        }
    });
    return chartView;
}

private void openChart2() {
    long[] followers = new long[arralistEntityModels.size()];
    long[] followings = new long[arralistEntityModels.size()];
    long[] mutualFollowers = new long[arralistEntityModels.size()];
    long[] nonFollowers = new long[arralistEntityModels.size()];
    System.out.println("arralistEntityModels " + arralistEntityModels);
    for (int i = 0; i < arralistEntityModels.size(); i++) {
        followers[i] = arralistEntityModels.get(i).getFollowers();
        followings[i] = arralistEntityModels.get(i).getFollowings();
        mutualFollowers[i] = arralistEntityModels.get(i).getMutuals();
        nonFollowers[i] = arralistEntityModels.get(i).getNonfollwers();
        if (arralistEntityModels.get(i).getFollowers() > maxLimit) {
            maxLimit = arralistEntityModels.get(i).getFollowers();
        }
        if (arralistEntityModels.get(i).getFollowings() > maxLimit) {
            maxLimit = arralistEntityModels.get(i).getFollowings();
        }
        if (arralistEntityModels.get(i).getMutuals() > maxLimit) {
            maxLimit = arralistEntityModels.get(i).getMutuals();
        }
        if (arralistEntityModels.get(i).getNonfollwers() > maxLimit) {
            maxLimit = arralistEntityModels.get(i).getNonfollwers();
        }
    }
    maxLimit = maxLimit + 10;
    System.out.println("maxLimit = " + maxLimit);
    XYSeries xySeriesfollower = new XYSeries("Followers");
    XYSeries xySeriesfollowings = new XYSeries("Followings");
    XYSeries xySeriesmutualFollowers = new XYSeries("MutualFollowers");
    XYSeries xySeriesnonFollowers = new XYSeries("NonFollowers");
    // Adding data to Income and Expense Series
    for (int i = 0; i < arralistEntityModels.size(); i++) {
        xySeriesfollower.add(i, followers[i]);
        xySeriesfollowings.add(i, followings[i]);
        xySeriesmutualFollowers.add(i, mutualFollowers[i]);
        xySeriesnonFollowers.add(i, nonFollowers[i]);
    }
    // Creating a dataset to hold each series
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(xySeriesfollower);
    dataset.addSeries(xySeriesfollowings);
    dataset.addSeries(xySeriesmutualFollowers);
    dataset.addSeries(xySeriesnonFollowers);
    // Creating XYSeriesRenderer to customize incomeSeries
    XYSeriesRenderer rendererfollowers = new XYSeriesRenderer();
    // color of the graph set to
    rendererfollowers.setColor(Color.CYAN);
    // cyan
    rendererfollowers.setFillPoints(true);
    rendererfollowers.setLineWidth(2f);
    rendererfollowers.setDisplayChartValues(true);
    // setting chart value distance
    rendererfollowers.setDisplayChartValuesDistance(10);
    // setting line graph point style to circle
    rendererfollowers.setPointStyle(PointStyle.POINT);
    // setting stroke of the line chart to solid
    rendererfollowers.setStroke(BasicStroke.SOLID);
    // Creating XYSeriesRenderer to customize expenseSeries
    XYSeriesRenderer rendererFollowings = new XYSeriesRenderer();
    rendererFollowings.setColor(Color.GREEN);
    rendererFollowings.setFillPoints(true);
    rendererFollowings.setLineWidth(2f);
    rendererFollowings.setDisplayChartValues(true);
    // setting line graph point style to circle
    rendererFollowings.setPointStyle(PointStyle.POINT);
    // setting stroke of the line chart to solid
    rendererFollowings.setStroke(BasicStroke.SOLID);
    XYSeriesRenderer rendererMutualFollowers = new XYSeriesRenderer();
    // color of the graph
    rendererMutualFollowers.setColor(Color.YELLOW);
    // set to cyan
    rendererMutualFollowers.setFillPoints(true);
    rendererMutualFollowers.setLineWidth(2f);
    rendererMutualFollowers.setDisplayChartValues(true);
    // setting chart value distance
    rendererMutualFollowers.setDisplayChartValuesDistance(10);
    // setting line graph point style to circle
    rendererMutualFollowers.setPointStyle(PointStyle.POINT);
    // setting stroke of the line chart to solid
    rendererMutualFollowers.setStroke(BasicStroke.SOLID);
    // Creating XYSeriesRenderer to customize expenseSeries
    XYSeriesRenderer rendererNonFollowers = new XYSeriesRenderer();
    rendererNonFollowers.setColor(Color.RED);
    rendererNonFollowers.setFillPoints(true);
    rendererNonFollowers.setLineWidth(2f);
    rendererNonFollowers.setDisplayChartValues(true);
    // setting line graph point style to circle
    rendererNonFollowers.setPointStyle(PointStyle.POINT);
    // setting stroke of the line chart to solid
    rendererNonFollowers.setStroke(BasicStroke.SOLID);
    // Creating a XYMultipleSeriesRenderer to customize the whole chart
    XYMultipleSeriesRenderer multiRenderer = new XYMultipleSeriesRenderer();
    multiRenderer.setXLabels(0);
    multiRenderer.setChartTitle("Followers Analysis");
    multiRenderer.setXTitle("Year 2015");
    multiRenderer.setYTitle("Followers List");
    /***
		 * Customizing graphs
		 */
    // setting text size of the title
    multiRenderer.setChartTitleTextSize(28);
    // setting text size of the axis title
    multiRenderer.setAxisTitleTextSize(20);
    // setting text size of the graph lable
    multiRenderer.setLabelsTextSize(12);
    // setting zoom buttons visiblity
    // multiRenderer.setZoomButtonsVisible(true);
    // setting pan enablity which uses graph to move on both axis
    // multiRenderer.setPanEnabled(false, false);
    // setting click false on graph
    multiRenderer.setClickEnabled(false);
    // setting zoom to false on both axis
    // multiRenderer.setZoomEnabled(true, true);
    // setting lines to display on y axis
    multiRenderer.setShowGridY(true);
    // setting lines to display on x axis
    multiRenderer.setShowGridX(true);
    // setting legend to fit the screen size
    multiRenderer.setFitLegend(true);
    // setting displaying line on grid
    multiRenderer.setShowGrid(true);
    // setting zoom to false
    multiRenderer.setZoomEnabled(false);
    // setting external zoom functions to false
    multiRenderer.setExternalZoomEnabled(false);
    // setting displaying lines on graph to be formatted(like using
    // graphics)
    multiRenderer.setAntialiasing(false);
    // setting to in scroll to false
    multiRenderer.setInScroll(false);
    // setting to set legend height of the graph
    multiRenderer.setLegendHeight(30);
    // setting x axis label align
    multiRenderer.setXLabelsAlign(Align.CENTER);
    // setting y axis label to align
    multiRenderer.setYLabelsAlign(Align.LEFT);
    // setting text style
    multiRenderer.setTextTypeface("sans_serif", Typeface.NORMAL);
    // setting no of values to display in y axis
    multiRenderer.setYLabels(10);
    // setting y axis max value, Since i'm using static values inside the
    // graph so i'm setting y max value to 4000.
    // if you use dynamic values then get the max y value and set here
    multiRenderer.setYAxisMax(maxLimit);
    // setting used to move the graph on xaxiz to .5 to the right
    // multiRenderer.setXAxisMin(0.5);
    // setting used to move the graph on xaxiz to .5 to the right
    multiRenderer.setXAxisMax(arralistEntityModels.size());
    // setting bar size or space between two bars
    multiRenderer.setBarSpacing(0.5);
    // Setting background color of the graph to transparent
    multiRenderer.setBackgroundColor(Color.BLACK);
    // Setting margin color of the graph to transparent
    multiRenderer.setMarginsColor(getResources().getColor(android.R.color.transparent));
    multiRenderer.setApplyBackgroundColor(true);
    multiRenderer.setScale(2f);
    // setting x axis point size
    multiRenderer.setPointSize(4f);
    // setting the margin size for the graph in the order top, left, bottom,
    // right
    multiRenderer.setMargins(new int[] { 30, 30, 30, 30 });
    DateFormat dateFormat = new SimpleDateFormat("MM/dd");
    for (int i = 0; i < arralistEntityModels.size(); i++) {
        Date date = new Date(arralistEntityModels.get(i).getMillis());
        // 2014/08/06
        System.out.println(dateFormat.format(date));
        if (i == 0) {
            multiRenderer.addXTextLabel(i, "" + 0);
        } else {
            multiRenderer.addXTextLabel(i, dateFormat.format(date));
        }
    }
    // Adding incomeRenderer and expenseRenderer to multipleRenderer
    // Note: The order of adding dataseries to dataset and renderers to
    // multipleRenderer
    // should be same
    multiRenderer.addSeriesRenderer(rendererfollowers);
    multiRenderer.addSeriesRenderer(rendererFollowings);
    multiRenderer.addSeriesRenderer(rendererMutualFollowers);
    multiRenderer.addSeriesRenderer(rendererNonFollowers);
    multiRenderer.setPanEnabled(false, false);
    multiRenderer.setYAxisMin(0);
    multiRenderer.setXAxisMin(0);
    // this part is used to display graph on the xml
    LinearLayout chartContainer = (LinearLayout) rootview.findViewById(R.id.chart);
    // remove any views before u paint the chart
    chartContainer.removeAllViews();
    // drawing bar chart
    System.out.println("dataset " + dataset.toString());
    System.out.println("multiRenderer " + multiRenderer.toString());
    mChart = ChartFactory.getLineChartView(FragmentsStatistics.this.getActivity(), dataset, multiRenderer);
    mChart.setClickable(false);
    // adding the view to the linearlayout
    chartContainer.addView(mChart);
// Creating an intent to plot bar chart using dataset and
// multipleRenderer
}

/**
	 * ³õʼ»¯ÅäÖÃ
	 */
@SuppressWarnings("deprecation")
private void initConfig() {
    //ÇúÏß
    context = getApplicationContext();
    //ÕâÀï»ñµÃmain½çÃæÉϵIJ¼¾Ö£¬ÏÂÃæ»á°Ñͼ±í»­ÔÚÕâ¸ö²¼¾ÖÀïÃæ
    LinearLayout layout = (LinearLayout) findViewById(R.id.id_linearLayout_graph);
    //Õâ¸öÀàÓÃÀ´·ÅÖÃÇúÏßÉϵÄËùÓе㣬ÊÇÒ»¸öµãµÄ¼¯ºÏ£¬¸ù¾ÝÕâЩµã»­³öÇúÏß
    series = new XYSeries(title);
    //´´½¨Ò»¸öÊý¾Ý¼¯µÄʵÀý£¬Õâ¸öÊý¾Ý¼¯½«±»ÓÃÀ´´´½¨Í¼±í
    mDataset = new XYMultipleSeriesDataset();
    //½«µã¼¯Ìí¼Óµ½Õâ¸öÊý¾Ý¼¯ÖÐ
    mDataset.addSeries(series);
    //ÒÔ϶¼ÊÇÇúÏßµÄÑùʽºÍÊôÐԵȵȵÄÉèÖã¬rendererÏ൱ÓÚÒ»¸öÓÃÀ´¸øͼ±í×öäÖȾµÄ¾ä±ú
    int color = Color.GREEN;
    PointStyle style = PointStyle.CIRCLE;
    renderer = buildRenderer(color, style, true);
    //ÉèÖúÃͼ±íµÄÑùʽ
    setChartSettings(renderer, "X", "Y", 0, 300, 4, 16, Color.WHITE, Color.WHITE);
    //Éú³Éͼ±í
    chart = ChartFactory.getLineChartView(context, mDataset, renderer);
    //½«Í¼±íÌí¼Óµ½²¼¾ÖÖÐÈ¥
    layout.addView(chart, new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
    //ÕâÀïµÄHandlerʵÀý½«ÅäºÏÏÂÃæµÄTimerʵÀý£¬Íê³É¶¨Ê±¸üÐÂͼ±íµÄ¹¦ÄÜ
    handler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            //Ë¢ÐÂͼ±í
            updateChart();
            super.handleMessage(msg);
        }
    };
    task = new TimerTask() {

        @Override
        public void run() {
            Message message = new Message();
            message.what = 1;
            handler.sendMessage(message);
        }
    };
    //ÇúÏß
    timer.schedule(task, 1, 20);
    //»ñÈ¡SurfaceView¿Ø¼þ
    preview = (SurfaceView) findViewById(R.id.id_preview);
    previewHolder = preview.getHolder();
    previewHolder.addCallback(surfaceCallback);
    previewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    mTV_Heart_Rate = (TextView) findViewById(R.id.id_tv_heart_rate);
    mTV_Avg_Pixel_Values = (TextView) findViewById(R.id.id_tv_Avg_Pixel_Values);
    mTV_pulse = (TextView) findViewById(R.id.id_tv_pulse);
    PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
    wakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, "DoNotDimScreen");
}

private View createTempGraph() {
    // We start creating the XYSeries to plot the temperature
    XYSeries series = new XYSeries("London Temperature hourly");
    // We start filling the series
    int hour = 0;
    for (HourForecast hf : nextHourForecast) {
        series.add(hour++, hf.weather.temperature.getTemp());
    }
    // Now we create the renderer
    XYSeriesRenderer renderer = new XYSeriesRenderer();
    renderer.setLineWidth(2);
    renderer.setColor(Color.RED);
    // Include low and max value
    renderer.setDisplayBoundingPoints(true);
    // we add point markers
    renderer.setPointStyle(PointStyle.CIRCLE);
    renderer.setPointStrokeWidth(3);
    // Now we add our series
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    dataset.addSeries(series);
    // Finaly we create the multiple series renderer to control the graph
    XYMultipleSeriesRenderer mRenderer = new XYMultipleSeriesRenderer();
    mRenderer.addSeriesRenderer(renderer);
    // We want to avoid black border
    // transparent margins
    mRenderer.setMarginsColor(Color.argb(0x00, 0xff, 0x00, 0x00));
    // Disable Pan on two axis
    mRenderer.setPanEnabled(false, false);
    mRenderer.setYAxisMax(35);
    mRenderer.setYAxisMin(0);
    // we show the grid
    mRenderer.setShowGrid(true);
    GraphicalView chartView = ChartFactory.getLineChartView(getActivity(), dataset, mRenderer);
    // Enable chart click
    mRenderer.setClickEnabled(true);
    chartView.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            applyAnim(v, createPressGraph());
        }
    });
    return chartView;
}

private View createLineView() {
    // Categories
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    String[] labels = this.sensor.getLabels().split(";");
    int nb_values = 0;
    try {
        nb_values = this.sensor.getMeasures().get(0).getValue().split(";").length;
    } catch (IndexOutOfBoundsException ioobe) {
        return this.createTextView();
    }
    for (int i = 0; i < nb_values; i++) {
        TimeSeries timeSerie = new TimeSeries(labels[i]);
        for (int j = 0; j < this.sensor.getMeasures().size(); j++) {
            Double value = new Double(this.sensor.getMeasures().get(j).getValue().split(";")[i]);
            Date date = this.sensor.getMeasures().get(j).getTimestamp();
            timeSerie.add(date, value);
        }
        dataset.addSeries(timeSerie);
    }
    // Renderer
    XYMultipleSeriesRenderer renderer = this.getDefaultRenderer();
    for (int color : Arrays.copyOfRange(this.colors, 0, nb_values)) {
        XYSeriesRenderer r = new XYSeriesRenderer();
        r.setColor(color);
        r.setFillBelowLine(true);
        r.setFillBelowLine(false);
        r.setFillPoints(true);
        r.setLineWidth(2);
        renderer.addSeriesRenderer(r);
    }
    renderer.setShowLegend(true);
    renderer.setPanEnabled(false, false);
    renderer.setZoomEnabled(false, false);
    renderer.setGridColor(this.lightFontColor);
    renderer.setMarginsColor(this.backgroundColor);
    renderer.setXLabelsColor(this.fontColor);
    renderer.setYLabelsColor(0, this.fontColor);
    renderer.setYLabelsAlign(Align.RIGHT);
    renderer.setYAxisMin(0);
    renderer.setXLabels(0);
    int count = dataset.getSeriesAt(0).getItemCount();
    String dateFormat = "HH:mm\nMMM dd";
    if (this.period.equals("hour")) {
        dateFormat = "HH:mm";
    }
    for (int i = 0; i < count; i = i + (count / 5)) {
        Double d = dataset.getSeriesAt(0).getX(i);
        Date date = this.sensor.getMeasures().get(i).getTimestamp();
        String s = new SimpleDateFormat(dateFormat).format(date);
        renderer.addXTextLabel(d, s);
    }
    this.setYAxisValues(dataset, renderer);
    return ChartFactory.getTimeChartView(this.context, dataset, renderer, dateFormat);
}

/**
	 * ³õʼ»¯ÅäÖÃ
	 */
@SuppressWarnings("deprecation")
private void initConfig() {
    //ÇúÏß
    context = getApplicationContext();
    //ÕâÀï»ñµÃmain½çÃæÉϵIJ¼¾Ö£¬ÏÂÃæ»á°Ñͼ±í»­ÔÚÕâ¸ö²¼¾ÖÀïÃæ
    LinearLayout layout = (LinearLayout) findViewById(R.id.id_linearLayout_graph);
    //Õâ¸öÀàÓÃÀ´·ÅÖÃÇúÏßÉϵÄËùÓе㣬ÊÇÒ»¸öµãµÄ¼¯ºÏ£¬¸ù¾ÝÕâЩµã»­³öÇúÏß
    series = new XYSeries(title);
    //´´½¨Ò»¸öÊý¾Ý¼¯µÄʵÀý£¬Õâ¸öÊý¾Ý¼¯½«±»ÓÃÀ´´´½¨Í¼±í
    mDataset = new XYMultipleSeriesDataset();
    //½«µã¼¯Ìí¼Óµ½Õâ¸öÊý¾Ý¼¯ÖÐ
    mDataset.addSeries(series);
    //ÒÔ϶¼ÊÇÇúÏßµÄÑùʽºÍÊôÐԵȵȵÄÉèÖã¬rendererÏ൱ÓÚÒ»¸öÓÃÀ´¸øͼ±í×öäÖȾµÄ¾ä±ú
    int color = Color.GREEN;
    PointStyle style = PointStyle.CIRCLE;
    renderer = buildRenderer(color, style, true);
    //ÉèÖúÃͼ±íµÄÑùʽ
    setChartSettings(renderer, "X", "Y", 0, 300, 4, 16, Color.WHITE, Color.WHITE);
    //Éú³Éͼ±í
    chart = ChartFactory.getLineChartView(context, mDataset, renderer);
    //½«Í¼±íÌí¼Óµ½²¼¾ÖÖÐÈ¥
    layout.addView(chart, new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
    //ÕâÀïµÄHandlerʵÀý½«ÅäºÏÏÂÃæµÄTimerʵÀý£¬Íê³É¶¨Ê±¸üÐÂͼ±íµÄ¹¦ÄÜ
    handler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            //Ë¢ÐÂͼ±í
            updateChart();
            super.handleMessage(msg);
        }
    };
    task = new TimerTask() {

        @Override
        public void run() {
            Message message = new Message();
            message.what = 1;
            handler.sendMessage(message);
        }
    };
    //ÇúÏß
    timer.schedule(task, 1, 20);
    //»ñÈ¡SurfaceView¿Ø¼þ
    preview = (SurfaceView) findViewById(R.id.id_preview);
    previewHolder = preview.getHolder();
    previewHolder.addCallback(surfaceCallback);
    previewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    mTV_Heart_Rate = (TextView) findViewById(R.id.id_tv_heart_rate);
    mTV_Avg_Pixel_Values = (TextView) findViewById(R.id.id_tv_Avg_Pixel_Values);
    mTV_pulse = (TextView) findViewById(R.id.id_tv_pulse);
    PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
    wakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, "DoNotDimScreen");
}

/**
	 * Sets up all parameters for display of both the chart on the screen 
	 * AND a color coded display of the parameters and their values 
	 */
private void generateChart() {
    // Set up chart
    XYMultipleSeriesDataset deviceDataset = new XYMultipleSeriesDataset();
    XYMultipleSeriesRenderer deviceRenderer = new XYMultipleSeriesRenderer();
    LinearLayout layout = (LinearLayout) findViewById(R.id.deviceChart);
    if (mDeviceChartView != null) {
        layout.removeView(mDeviceChartView);
    }
    if (true) {
        mDeviceChartView = ChartFactory.getLineChartView(this, deviceDataset, deviceRenderer);
        mDeviceChartView.setBackgroundColor(Color.BLACK);
        layout.addView(mDeviceChartView, new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
    }
    deviceRenderer.setShowLabels(false);
    deviceRenderer.setMargins(new int[] { 0, 5, 5, 0 });
    deviceRenderer.setShowAxes(true);
    deviceRenderer.setShowLegend(false);
    deviceRenderer.setZoomEnabled(false, false);
    deviceRenderer.setPanEnabled(false, false);
    deviceRenderer.setYAxisMin(0);
    deviceRenderer.setYAxisMax(100);
    SpannableStringBuilder sMeasuresText = new SpannableStringBuilder("Displaying: ");
    ArrayList<Long> visibleIds = getVisibleIds(KEY_NAME);
    int keyCount = mBioParameters.size();
    keyCount = mBioParameters.size();
    int lineNum = 0;
    for (int i = 0; i < mBioParameters.size(); ++i) {
        GraphBioParameter item = mBioParameters.get(i);
        item.visible = visibleIds.contains(item.id);
        if (!item.visible) {
            continue;
        }
        deviceDataset.addSeries(item.series);
        item.color = getKeyColor(i, keyCount);
        // Add name of the measure to the displayed text field
        ForegroundColorSpan fcs = new ForegroundColorSpan(item.color);
        int start = sMeasuresText.length();
        sMeasuresText.append(mBioParameters.get(i).title1 + ", ");
        int end = sMeasuresText.length();
        sMeasuresText.setSpan(fcs, start, end, Spannable.SPAN_INCLUSIVE_INCLUSIVE);
        if (sMeasuresText.length() > 40 && lineNum == 0) {
            lineNum++;
        }
        XYSeriesRenderer seriesRenderer = new XYSeriesRenderer();
        seriesRenderer.setColor(item.color);
        seriesRenderer.setPointStyle(PointStyle.CIRCLE);
        deviceRenderer.addSeriesRenderer(seriesRenderer);
    }
    mMeasuresDisplayText.setText(sMeasuresText);
}

private void generateChart() {
    // Set up chart
    XYMultipleSeriesDataset deviceDataset = new XYMultipleSeriesDataset();
    XYMultipleSeriesRenderer deviceRenderer = new XYMultipleSeriesRenderer();
    LinearLayout layout = (LinearLayout) findViewById(R.id.deviceChart);
    if (mDeviceChartView != null) {
        layout.removeView(mDeviceChartView);
    }
    if (true) {
        mDeviceChartView = ChartFactory.getLineChartView(this, deviceDataset, deviceRenderer);
        mDeviceChartView.setBackgroundColor(Color.BLACK);
        layout.addView(mDeviceChartView, new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
    }
    deviceRenderer.setShowLabels(false);
    deviceRenderer.setMargins(new int[] { 0, 5, 5, 0 });
    deviceRenderer.setShowAxes(true);
    deviceRenderer.setShowLegend(false);
    deviceRenderer.setZoomEnabled(false, false);
    deviceRenderer.setPanEnabled(false, false);
    deviceRenderer.setYAxisMin(0);
    //        deviceRenderer.setYAxisMax(1000);
    // This is set rather arbitrarily based on observed resistance values in the log
    deviceRenderer.setYAxisMax(8000000);
    deviceDataset.addSeries(mSeries);
    XYSeriesRenderer seriesRenderer = new XYSeriesRenderer();
    seriesRenderer.setColor(Color.WHITE);
    seriesRenderer.setPointStyle(PointStyle.CIRCLE);
    deviceRenderer.addSeriesRenderer(seriesRenderer);
}

// initialises the graph
private void init() {
    Log.d(TAG, "init");
    layoutPointData.setVisibility(View.GONE);
    chartLayout.removeAllViews();
    chart = null;
    data = new HashMap<>();
    List<SensorData> sensors = SingleInstance.getUserController().getUser().getSensors();
    if (sensors.size() == 0) {
        textViewNoData.setVisibility(View.VISIBLE);
        textViewNoData.setText(R.string.chart_text_no_sensor);
        refreshingView.setVisibility(View.GONE);
    } else {
        textViewNoData.setText(R.string.chart_text_no_data);
    }
    for (SensorData sensor : sensors) {
        data.put(sensor.getSensorId(), new ChartSerieRendererContainer(sensor));
    }
    textViewNoData.setVisibility(View.VISIBLE);
    originalChartDataset = new XYMultipleSeriesDataset();
    currentChartDataset = new XYMultipleSeriesDataset();
    chartRenderer = new XYMultipleSeriesRenderer();
    chartRenderer.setApplyBackgroundColor(true);
    chartRenderer.setBackgroundColor(Color.WHITE);
    chartRenderer.setAxesColor(Color.DKGRAY);
    chartRenderer.setMarginsColor(Color.WHITE);
    chartRenderer.setGridColor(Color.LTGRAY);
    chartRenderer.setXLabelsColor(Color.DKGRAY);
    chartRenderer.setYLabelsColor(0, Color.DKGRAY);
    //chartRenderer.setZoomEnabled(true);
    //chartRenderer.setPanEnabled(true);
    chartRenderer.setZoomEnabled(true, false);
    chartRenderer.setPanEnabled(true, false);
    chartRenderer.setClickEnabled(true);
    chartRenderer.setShowGrid(true);
    chartRenderer.setXLabelFormat(new DecimalFormat() {

        @Override
        public StringBuffer format(double value, StringBuffer buffer, FieldPosition position) {
            Date dateFormat = new Date(((long) value) * 1000);
            buffer.append(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(dateFormat));
            return buffer;
        }
    });
    chartRenderer.setShowLegend(false);
    minimalX = Integer.MAX_VALUE;
    maximalX = 0;
    maximalY = 0;
}

/**
     * Create the components that go into the chart.
     *
     * <p>This method is protected, rather than private, due to a bug between JaCoCo and
     * the Android build tools which causes the instrumented bytecode to be invalid when this
     * method is private:
     * http://stackoverflow.com/questions/17603192/dalvik-transformation-using-wrong-invoke-opcode
     * </p>
     */
protected void buildGraphPieces() {
    if (mRenderer != null || mDataset != null || mRpmRenderer != null || mSpeedRenderer != null) {
        // Don't want to leak any memory or whatnot.
        return;
    }
    mRenderer = new XYMultipleSeriesRenderer(2);
    mDataset = new XYMultipleSeriesDataset();
    mSpeedRenderer = new XYSeriesRenderer();
    mRpmRenderer = new XYSeriesRenderer();
    // Initialize renderer settings
    mRenderer.setShowGrid(true);
    mRenderer.setFitLegend(true);
    // Number of grid lines in either direction by default
    mRenderer.setXLabels(0);
    mRenderer.setYLabels(10);
    mRenderer.setXLabelsAlign(Align.RIGHT);
    mRenderer.setYLabelsAlign(Align.RIGHT);
    mRenderer.setPointSize(5f);
    // AChartEngine output defaults to a black background.
    // This doesn't fit with the general WVA color scheme.
    mRenderer.setApplyBackgroundColor(true);
    mRenderer.setBackgroundColor(Color.WHITE);
    mRenderer.setMarginsColor(Color.WHITE);
    mRenderer.setAxesColor(Color.DKGRAY);
    mRenderer.setLabelsColor(Color.BLACK);
    mRenderer.setXLabelsColor(Color.DKGRAY);
    mRenderer.setYLabelsColor(0, Color.DKGRAY);
    mRenderer.setYLabelsColor(1, Color.DKGRAY);
    mRenderer.setGridColor(Color.LTGRAY);
    mRenderer.setPanEnabled(false, false);
    mRenderer.setZoomEnabled(false, false);
    mRenderer.setXAxisMin(startTime);
    mRenderer.setXAxisMax(endTime);
    mRenderer.setXAxisMin(startTime, 1);
    mRenderer.setXAxisMax(endTime, 1);
    mRenderer.setYAxisMin(0, 0);
    mRenderer.setYAxisMax(100, 0);
    mSpeedRenderer.setColor(Color.RED);
    mSpeedRenderer.setPointStyle(PointStyle.CIRCLE);
    mSpeedRenderer.setFillPoints(true);
    mRpmRenderer.setColor(Color.BLUE);
    mRpmRenderer.setPointStyle(PointStyle.SQUARE);
    mRpmRenderer.setFillPoints(true);
    XYSeries speedSeries = new XYSeries("Vehicle Speed");
    XYSeries rpmSeries = new XYSeries("Engine RPM", 1);
    mDataset.addSeries(0, speedSeries);
    mDataset.addSeries(1, rpmSeries);
    mRenderer.addSeriesRenderer(0, mSpeedRenderer);
    mRenderer.addSeriesRenderer(1, mRpmRenderer);
    mRenderer.setYAxisMin(0, 1);
    mRenderer.setYAxisMax(10000, 1);
    mRenderer.setYTitle("VehicleSpeed");
    mRenderer.setYTitle("EngineSpeed", 1);
    mRenderer.setYAxisAlign(Align.RIGHT, 1);
    mRenderer.setYLabelsAlign(Align.RIGHT, 1);
    // Add X-axis labels with time.
    Log.d(TAG, "Time range: " + startTime + " to " + endTime);
    SimpleDateFormat fmt = new SimpleDateFormat("HH:mm:ss", Locale.US);
    for (double t = startTime; t <= endTime; t += 60 * 1000) {
        String time = fmt.format(new Date((long) t));
        Log.d(TAG, "Adding label " + t + ", " + time);
        mRenderer.addXTextLabel(t, time);
    }
}

private void onCreate() {
    this.state_key = feature.getState_key();
    this.dev_id = feature.getDevId();
    this.parameters = feature.getParameters();
    this.id = feature.getId();
    this.isopen = false;
    try {
        int graphics_height_size = params.getInt("graphics_height_size", 262);
        this.Float_graph_size = Float.valueOf(graphics_height_size);
    } catch (Exception e) {
        String graph_size = params.getString("graph_size", "262.5");
        this.Float_graph_size = Float.valueOf(graph_size);
    }
    format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    mytag = "Graphical_Info_with_achartengine (" + dev_id + ")";
    try {
        stateS = getResources().getString(translate.do_translate(getContext(), Tracer, state_key));
    } catch (Exception e) {
        stateS = state_key;
    }
    myself = this;
    setOnClickListener(this);
    DisplayMetrics metrics = getResources().getDisplayMetrics();
    //Label Text size according to the screen size
    float size12 = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 12, metrics);
    size10 = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 10, metrics);
    size5 = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 5, metrics);
    float size2 = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 2, metrics);
    //Design the graph
    //Creating a XYMultipleSeriesRenderer to customize the whole chart
    multiRenderer = new XYMultipleSeriesRenderer();
    //Creating XYSeriesRenderer to customize incomeSeries
    incomeRenderer = new XYSeriesRenderer();
    emptyRenderer = new XYSeriesRenderer();
    //Creating a dataset to hold each series
    dataset = new XYMultipleSeriesDataset();
    //Creating an  XYSeries for Income
    nameSeries = new TimeSeries(name);
    EmptySeries = new TimeSeries(getResources().getString(translate.do_translate(getContext(), Tracer, "no_value")));
    incomeRenderer.setColor(0xff0B909A);
    emptyRenderer.setColor(0xffff0000);
    incomeRenderer.setPointStyle(PointStyle.CIRCLE);
    //emptyRenderer.setPointStyle(PointStyle.CIRCLE);
    incomeRenderer.setFillPoints(true);
    emptyRenderer.setFillPoints(true);
    incomeRenderer.setLineWidth(4);
    emptyRenderer.setLineWidth(4);
    incomeRenderer.setDisplayChartValues(true);
    emptyRenderer.setDisplayChartValues(false);
    incomeRenderer.setChartValuesTextSize(size12);
    //Change the type of line between point
    //incomeRenderer.setStroke(BasicStroke.DASHED);
    //Remove default X axis label
    //multiRenderer.setXLabels(0);
    //Set X title
    multiRenderer.setXTitle(getResources().getString(translate.do_translate(getContext(), Tracer, "time")));
    //Remove default Y axis label
    multiRenderer.setYLabels(0);
    //Set X label text color
    multiRenderer.setXLabelsColor(Color.BLACK);
    //Set Y label text color
    multiRenderer.setYLabelsColor(0, Color.BLACK);
    //Set X label text size
    multiRenderer.setLabelsTextSize(size10);
    //Set X label text angle
    multiRenderer.setXLabelsAngle(-15);
    //Set Y label text angle
    multiRenderer.setYLabelsAngle(-10);
    //Set X label text alignement
    multiRenderer.setXLabelsAlign(Align.CENTER);
    //Set to make TV_Value of y axis left aligned
    multiRenderer.setYLabelsAlign(Align.LEFT);
    //Disable zoom button
    multiRenderer.setZoomButtonsVisible(false);
    //get background transparent
    multiRenderer.setMarginsColor(Color.argb(0x00, 0xff, 0x00, 0x00));
    //Disable Zoom in Y axis
    multiRenderer.setZoomEnabled(true, false);
    //Disable Pan in Y axis
    multiRenderer.setPanEnabled(true, false);
    //Limits pan mouvement
    //[panMinimumX, panMaximumX, panMinimumY, panMaximumY]
    //double[] panLimits={-5,26,0,0};
    //multiRenderer.setPanLimits(panLimits);
    //Sets the selectable radius TV_Value around clickable points.
    multiRenderer.setSelectableBuffer(10);
    //Add grid
    multiRenderer.setShowGrid(true);
    //Set color for grid
    multiRenderer.setGridColor(Color.BLACK, 0);
    //To allow on click method (called when pan or zoom aplied)
    multiRenderer.setClickEnabled(true);
    Tracer.i(mytag, "New instance for name = " + name + " state_key = " + state_key);
    //state key
    state_key_view = new TextView(activity);
    state_key_view.setText(stateS);
    state_key_view.setTextColor(Color.parseColor("#333333"));
    //TV_Value
    TV_Value = new TextView(activity);
    TV_Value.setTextSize(28);
    TV_Value.setTextColor(Color.BLACK);
    TV_Value.setGravity(Gravity.RIGHT);
    Animation animation = new AlphaAnimation(0.0f, 1.0f);
    animation.setDuration(1000);
    TV_Timestamp = new RelativeTimeTextView(activity, null);
    TV_Timestamp.setTextSize(10);
    TV_Timestamp.setTextColor(Color.BLUE);
    TV_Timestamp.setGravity(Gravity.RIGHT);
    super.LL_featurePan.addView(TV_Value);
    super.LL_featurePan.addView(TV_Timestamp);
    super.LL_infoPan.addView(state_key_view);
    test_unite = "";
    try {
        //Basilic add, number feature has a unit parameter
        JSONObject jparam = new JSONObject(parameters.replaceAll(""", "\""));
        test_unite = jparam.getString("unit");
    } catch (JSONException jsonerror) {
        Tracer.i(mytag, "No unit for this feature");
    }
    Handler handler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 9999) {
                //state_engine send us a signal to notify TV_Value changed
                if (session == null)
                    return;
                String new_val = session.getValue();
                String Value_timestamp = session.getTimestamp();
                Tracer.d(mytag, "Handler receives a new TV_Value <" + new_val + "> at " + Value_timestamp);
                Long Value_timestamplong = null;
                Value_timestamplong = Long.valueOf(Value_timestamp) * 1000;
                display_sensor_info.display(Tracer, new_val, Value_timestamplong, mytag, parameters, TV_Value, TV_Timestamp, activity, LL_featurePan, typefaceweather, typefaceawesome, state_key, state_key_view, stateS, test_unite);
                //Change icon if in %
                if ((state_key.equalsIgnoreCase("humidity")) || (state_key.equalsIgnoreCase("percent")) || (test_unite.equals("%"))) {
                    if (Float.parseFloat(new_val) >= 60) {
                        //To have the icon colored if TV_Value beetwen 30 and 60
                        change_this_icon(2);
                    } else if (Float.parseFloat(new_val) >= 30) {
                        //To have the icon colored if TV_Value >30
                        change_this_icon(1);
                    } else {
                        //To have the icon colored if TV_Value <30
                        change_this_icon(0);
                    }
                } else {
                    // #93
                    if (new_val.equals("off") || new_val.equals("false") || new_val.equals("0") || new_val.equals("0.0")) {
                        change_this_icon(0);
                    //set featuremap.state to 1 so it could select the correct icon in entity_map.get_ressources
                    } else {
                        change_this_icon(2);
                    }
                }
            } else if (msg.what == 9998) {
                // state_engine send us a signal to notify it'll die !
                Tracer.d(mytag, "state engine disappeared ===> Harakiri !");
                session = null;
                realtime = false;
                removeView(LL_background);
                myself.setVisibility(GONE);
                if (container != null) {
                    container.removeView(myself);
                    container.recomputeViewAttributes(myself);
                }
                try {
                    finalize();
                } catch (Throwable t) {
                    t.printStackTrace();
                }
            //kill the handler thread itself
            }
        }
    };
    //================================================================================
    /*
         * New mechanism to be notified by widgetupdate engine when our TV_Value is changed
		 * 
		 */
    WidgetUpdate cache_engine = WidgetUpdate.getInstance();
    if (cache_engine != null) {
        if (api_version <= 0.6f) {
            session = new Entity_client(dev_id, state_key, mytag, handler, session_type);
        } else if (api_version >= 0.7f) {
            session = new Entity_client(id, "", mytag, handler, session_type);
        }
        try {
            if (Tracer.get_engine().subscribe(session)) {
                //we're connected to engine
                realtime = true;
                //each time our TV_Value change, the engine will call handler
                //Force to consider current TV_Value in session
                handler.sendEmptyMessage(9999);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
//================================================================================
//updateTimer();	//Don't use anymore cyclic refresh....
}

/**
	 * Restore instance state when the activity is reconstructed after a destroy
	 * 
	 * This method restores:
	 * <ul>
	 * <li>cloudWatchInput: The input data (such as period, measure name etc) for the display</li>
	 * </ul>
	 */
@Override
public void onRestoreInstanceState(Bundle stateToRestore) {
    //restore alertDialogDisplayed boolean
    alertDialogDisplayed = stateToRestore.getBoolean("alertDialogDisplayed");
    Log.v(TAG, "alertDialogDisplayed = " + alertDialogDisplayed);
    alertDialogMessage = stateToRestore.getString("alertDialogMessage");
    //was a progress dialog being displayed? Restore the answer to this question.
    progressDialogDisplayed = stateToRestore.getBoolean("progressDialogDisplayed");
    Log.v(TAG + ".onRestoreInstanceState", "progressDialogDisplayed:" + progressDialogDisplayed);
    /*get the model data back, so that you can inform the model that the activity
		 * has come back up. */
    Object retained = getLastNonConfigurationInstance();
    if (retained instanceof MonitorInstanceModel) {
        Log.v(TAG, "Restoring monitorinstancemodel on activity restore...");
        monitorInstanceModel = (MonitorInstanceModel) retained;
        monitorInstanceModel.setActivity(this);
    } else if (retained instanceof CloudWatchMetricsModel) {
        Log.v(TAG, "Restoring metrics model on activity restore...");
        metricsModel = (CloudWatchMetricsModel) retained;
        metricsModel.setActivity(this);
    }
    //restore the input data
    cloudWatchInput = (CloudWatchInput) (stateToRestore.getSerializable("cloudWatchInput"));
    //restore the measure data if any
    measureNames = stateToRestore.getStringArrayList("measureNames");
    //restore the chart data
    multiRenderer = (XYMultipleSeriesRenderer) stateToRestore.getSerializable("multiRenderer");
    dataset = (XYMultipleSeriesDataset) stateToRestore.getSerializable("dataset");
    ((TextView) findViewById(R.id.monitorInstanceTextView)).setText(stateToRestore.getString("titleText"));
}

public XYMultipleSeriesDataset getBarDemoDataset() {
    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    CategorySeries seriesPrincipal = new CategorySeries("Principal");
    CategorySeries seriesInterest = new CategorySeries("Interest");
    CategorySeries seriesSavings = new CategorySeries("Savings");
    if (mtg == null) {
        Log.w("getBarDemoDataset", "mtg is null");
    }
    if (mtg.runningtotalinterest == null) {
        Log.w("getBarDemoDataset", "runningtotalinterest is null");
    }
    if (mtg.interestsaved == null) {
        Log.w("getBarDemoDataset", "interestsaved is null");
    }
    if (mtg == null || mtg.runningtotalprincipal == null || mtg.runningtotalinterest == null || mtg.interestsaved == null) {
        seriesPrincipal.add(0);
        seriesPrincipal.add(0);
        seriesInterest.add(0);
        seriesInterest.add(0);
        seriesSavings.add(0);
        seriesSavings.add(0);
    } else {
        if (listItems.listWidgets.size() == 0) {
            seriesPrincipal.add(0);
            seriesInterest.add(0);
            seriesSavings.add(0);
        } else {
            seriesPrincipal.add(mtg.runningtotalprincipal.doubleValue());
            seriesInterest.add(mtg.runningtotalinterest.doubleValue());
            seriesSavings.add(mtg.interestsaved.doubleValue());
        }
        seriesPrincipal.add(mtg.runningtotalprincipal.doubleValue());
        seriesInterest.add(mtg.runningtotalinterest.add(mtg.interestsaved).doubleValue());
        seriesSavings.add(0);
    }
    dataset.addSeries(seriesPrincipal.toXYSeries());
    dataset.addSeries(seriesInterest.toXYSeries());
    dataset.addSeries(seriesSavings.toXYSeries());
    return dataset;
/*


            for (int i = 0; i < SERIES_NR; i++) {
                CategorySeries series = new CategorySeries("Demo series " + (i + 1));
                for (int k = 0; k < nr; k++) {
                    series.add(100 + r.nextInt() % 100);
                }
                dataset.addSeries(series.toXYSeries());
            }
            return dataset;
            */
}

@Override
protected void onRestoreInstanceState(Bundle savedState) {
    super.onRestoreInstanceState(savedState);
    // restore the current data, for instance when changing the screen orientation
    mDataset = (XYMultipleSeriesDataset) savedState.getSerializable("dataset");
    mRenderer = (XYMultipleSeriesRenderer) savedState.getSerializable("renderer");
    mCurrentSeries = (XYSeries) savedState.getSerializable("current_series");
}

/**
   * Creates a combined XY chart view.
   * 
   * @param context the context
   * @param dataset the multiple series dataset (cannot be null)
   * @param renderer the multiple series renderer (cannot be null)
   * @param types the chart types (cannot be null)
   * @return a combined XY chart graphical view
   * @throws IllegalArgumentException if dataset is null or renderer is null or
   *           if a dataset number of items is different than the number of
   *           series renderers or number of chart types
   */
public static final GraphicalView getCombinedXYChartView(Context context, XYMultipleSeriesDataset dataset, XYMultipleSeriesRenderer renderer, String[] types) {
    if (dataset == null || renderer == null || types == null || dataset.getSeriesCount() != types.length) {
        throw new IllegalArgumentException("Dataset, renderer and types should be not null and the datasets series count should be equal to the types length");
    }
    checkParameters(dataset, renderer);
    CombinedXYChart chart = new CombinedXYChart(dataset, renderer, types);
    return new GraphicalView(context, chart);
}

public XYMultipleSeriesDataset getDataset() {
    return mDataset;
}