Java tutorial
/* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.ddmuilib.log.event; import com.android.ddmlib.log.EventContainer; import com.android.ddmlib.log.EventLogParser; import com.android.ddmlib.log.EventValueDescription; import com.android.ddmlib.log.InvalidTypeException; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.jfree.chart.axis.AxisLocation; import org.jfree.chart.axis.NumberAxis; import org.jfree.chart.plot.XYPlot; import org.jfree.chart.renderer.xy.AbstractXYItemRenderer; import org.jfree.chart.renderer.xy.XYAreaRenderer; import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer; import org.jfree.data.time.Millisecond; import org.jfree.data.time.TimeSeries; import org.jfree.data.time.TimeSeriesCollection; import java.util.ArrayList; import java.util.Collection; import java.util.Date; import java.util.HashMap; import java.util.Map; public class DisplayGraph extends EventDisplay { public DisplayGraph(String name) { super(name); } /** * Resets the display. */ @Override void resetUI() { Collection<TimeSeriesCollection> datasets = mValueTypeDataSetMap.values(); for (TimeSeriesCollection dataset : datasets) { dataset.removeAllSeries(); } if (mOccurrenceDataSet != null) { mOccurrenceDataSet.removeAllSeries(); } mValueDescriptorSeriesMap.clear(); mOcurrenceDescriptorSeriesMap.clear(); } /** * Creates the UI for the event display. * @param parent the parent composite. * @param logParser the current log parser. * @return the created control (which may have children). */ @Override public Control createComposite(final Composite parent, EventLogParser logParser, final ILogColumnListener listener) { String title = getChartTitle(logParser); return createCompositeChart(parent, logParser, title); } /** * Adds event to the display. */ @Override void newEvent(EventContainer event, EventLogParser logParser) { ArrayList<ValueDisplayDescriptor> valueDescriptors = new ArrayList<ValueDisplayDescriptor>(); ArrayList<OccurrenceDisplayDescriptor> occurrenceDescriptors = new ArrayList<OccurrenceDisplayDescriptor>(); if (filterEvent(event, valueDescriptors, occurrenceDescriptors)) { updateChart(event, logParser, valueDescriptors, occurrenceDescriptors); } } /** * Updates the chart with the {@link EventContainer} by adding the values/occurrences defined * by the {@link ValueDisplayDescriptor} and {@link OccurrenceDisplayDescriptor} objects from * the two lists. * <p/>This method is only called when at least one of the descriptor list is non empty. * @param event * @param logParser * @param valueDescriptors * @param occurrenceDescriptors */ private void updateChart(EventContainer event, EventLogParser logParser, ArrayList<ValueDisplayDescriptor> valueDescriptors, ArrayList<OccurrenceDisplayDescriptor> occurrenceDescriptors) { Map<Integer, String> tagMap = logParser.getTagMap(); Millisecond millisecondTime = null; long msec = -1; // If the event container is a cpu container (tag == 2721), and there is no descriptor // for the total CPU load, then we do accumulate all the values. boolean accumulateValues = false; double accumulatedValue = 0; if (event.mTag == 2721) { accumulateValues = true; for (ValueDisplayDescriptor descriptor : valueDescriptors) { accumulateValues &= (descriptor.valueIndex != 0); } } for (ValueDisplayDescriptor descriptor : valueDescriptors) { try { // get the hashmap for this descriptor HashMap<Integer, TimeSeries> map = mValueDescriptorSeriesMap.get(descriptor); // if it's not there yet, we create it. if (map == null) { map = new HashMap<Integer, TimeSeries>(); mValueDescriptorSeriesMap.put(descriptor, map); } // get the TimeSeries for this pid TimeSeries timeSeries = map.get(event.pid); // if it doesn't exist yet, we create it if (timeSeries == null) { // get the series name String seriesFullName = null; String seriesLabel = getSeriesLabel(event, descriptor); switch (mValueDescriptorCheck) { case EVENT_CHECK_SAME_TAG: seriesFullName = String.format("%1$s / %2$s", seriesLabel, descriptor.valueName); break; case EVENT_CHECK_SAME_VALUE: seriesFullName = String.format("%1$s", seriesLabel); break; default: seriesFullName = String.format("%1$s / %2$s: %3$s", seriesLabel, tagMap.get(descriptor.eventTag), descriptor.valueName); break; } // get the data set for this ValueType TimeSeriesCollection dataset = getValueDataset( logParser.getEventInfoMap().get(event.mTag)[descriptor.valueIndex].getValueType(), accumulateValues); // create the series timeSeries = new TimeSeries(seriesFullName, Millisecond.class); if (mMaximumChartItemAge != -1) { timeSeries.setMaximumItemAge(mMaximumChartItemAge * 1000); } dataset.addSeries(timeSeries); // add it to the map. map.put(event.pid, timeSeries); } // update the timeSeries. // get the value from the event double value = event.getValueAsDouble(descriptor.valueIndex); // accumulate the values if needed. if (accumulateValues) { accumulatedValue += value; value = accumulatedValue; } // get the time if (millisecondTime == null) { msec = (long) event.sec * 1000L + (event.nsec / 1000000L); millisecondTime = new Millisecond(new Date(msec)); } // add the value to the time series timeSeries.addOrUpdate(millisecondTime, value); } catch (InvalidTypeException e) { // just ignore this descriptor if there's a type mismatch } } for (OccurrenceDisplayDescriptor descriptor : occurrenceDescriptors) { try { // get the hashmap for this descriptor HashMap<Integer, TimeSeries> map = mOcurrenceDescriptorSeriesMap.get(descriptor); // if it's not there yet, we create it. if (map == null) { map = new HashMap<Integer, TimeSeries>(); mOcurrenceDescriptorSeriesMap.put(descriptor, map); } // get the TimeSeries for this pid TimeSeries timeSeries = map.get(event.pid); // if it doesn't exist yet, we create it. if (timeSeries == null) { String seriesLabel = getSeriesLabel(event, descriptor); String seriesFullName = String.format("[%1$s:%2$s]", tagMap.get(descriptor.eventTag), seriesLabel); timeSeries = new TimeSeries(seriesFullName, Millisecond.class); if (mMaximumChartItemAge != -1) { timeSeries.setMaximumItemAge(mMaximumChartItemAge); } getOccurrenceDataSet().addSeries(timeSeries); map.put(event.pid, timeSeries); } // update the series // get the time if (millisecondTime == null) { msec = (long) event.sec * 1000L + (event.nsec / 1000000L); millisecondTime = new Millisecond(new Date(msec)); } // add the value to the time series timeSeries.addOrUpdate(millisecondTime, 0); // the value is unused } catch (InvalidTypeException e) { // just ignore this descriptor if there's a type mismatch } } // go through all the series and remove old values. if (msec != -1 && mMaximumChartItemAge != -1) { Collection<HashMap<Integer, TimeSeries>> pidMapValues = mValueDescriptorSeriesMap.values(); for (HashMap<Integer, TimeSeries> pidMapValue : pidMapValues) { Collection<TimeSeries> seriesCollection = pidMapValue.values(); for (TimeSeries timeSeries : seriesCollection) { timeSeries.removeAgedItems(msec, true); } } pidMapValues = mOcurrenceDescriptorSeriesMap.values(); for (HashMap<Integer, TimeSeries> pidMapValue : pidMapValues) { Collection<TimeSeries> seriesCollection = pidMapValue.values(); for (TimeSeries timeSeries : seriesCollection) { timeSeries.removeAgedItems(msec, true); } } } } /** * Returns a {@link TimeSeriesCollection} for a specific {@link com.android.ddmlib.log.EventValueDescription.ValueType}. * If the data set is not yet created, it is first allocated and set up into the * {@link org.jfree.chart.JFreeChart} object. * @param type the {@link com.android.ddmlib.log.EventValueDescription.ValueType} of the data set. * @param accumulateValues */ private TimeSeriesCollection getValueDataset(EventValueDescription.ValueType type, boolean accumulateValues) { TimeSeriesCollection dataset = mValueTypeDataSetMap.get(type); if (dataset == null) { // create the data set and store it in the map dataset = new TimeSeriesCollection(); mValueTypeDataSetMap.put(type, dataset); // create the renderer and configure it depending on the ValueType AbstractXYItemRenderer renderer; if (type == EventValueDescription.ValueType.PERCENT && accumulateValues) { renderer = new XYAreaRenderer(); } else { XYLineAndShapeRenderer r = new XYLineAndShapeRenderer(); r.setBaseShapesVisible(type != EventValueDescription.ValueType.PERCENT); renderer = r; } // set both the dataset and the renderer in the plot object. XYPlot xyPlot = mChart.getXYPlot(); xyPlot.setDataset(mDataSetCount, dataset); xyPlot.setRenderer(mDataSetCount, renderer); // put a new axis label, and configure it. NumberAxis axis = new NumberAxis(type.toString()); if (type == EventValueDescription.ValueType.PERCENT) { // force percent range to be (0,100) fixed. axis.setAutoRange(false); axis.setRange(0., 100.); } // for the index, we ignore the occurrence dataset int count = mDataSetCount; if (mOccurrenceDataSet != null) { count--; } xyPlot.setRangeAxis(count, axis); if ((count % 2) == 0) { xyPlot.setRangeAxisLocation(count, AxisLocation.BOTTOM_OR_LEFT); } else { xyPlot.setRangeAxisLocation(count, AxisLocation.TOP_OR_RIGHT); } // now we link the dataset and the axis xyPlot.mapDatasetToRangeAxis(mDataSetCount, count); mDataSetCount++; } return dataset; } /** * Return the series label for this event. This only contains the pid information. * @param event the {@link EventContainer} * @param descriptor the {@link OccurrenceDisplayDescriptor} * @return the series label. * @throws InvalidTypeException */ private String getSeriesLabel(EventContainer event, OccurrenceDisplayDescriptor descriptor) throws InvalidTypeException { if (descriptor.seriesValueIndex != -1) { if (descriptor.includePid == false) { return event.getValueAsString(descriptor.seriesValueIndex); } else { return String.format("%1$s (%2$d)", event.getValueAsString(descriptor.seriesValueIndex), event.pid); } } return Integer.toString(event.pid); } /** * Returns the {@link TimeSeriesCollection} for the occurrence display. If the data set is not * yet created, it is first allocated and set up into the {@link org.jfree.chart.JFreeChart} object. */ private TimeSeriesCollection getOccurrenceDataSet() { if (mOccurrenceDataSet == null) { mOccurrenceDataSet = new TimeSeriesCollection(); XYPlot xyPlot = mChart.getXYPlot(); xyPlot.setDataset(mDataSetCount, mOccurrenceDataSet); OccurrenceRenderer renderer = new OccurrenceRenderer(); renderer.setBaseShapesVisible(false); xyPlot.setRenderer(mDataSetCount, renderer); mDataSetCount++; } return mOccurrenceDataSet; } /** * Gets display type * * @return display type as an integer */ @Override int getDisplayType() { return DISPLAY_TYPE_GRAPH; } /** * Sets the current {@link EventLogParser} object. */ @Override protected void setNewLogParser(EventLogParser logParser) { if (mChart != null) { mChart.setTitle(getChartTitle(logParser)); } } /** * Returns a meaningful chart title based on the value of {@link #mValueDescriptorCheck}. * * @param logParser the logParser. * @return the chart title. */ private String getChartTitle(EventLogParser logParser) { if (mValueDescriptors.size() > 0) { String chartDesc = null; switch (mValueDescriptorCheck) { case EVENT_CHECK_SAME_TAG: if (logParser != null) { chartDesc = logParser.getTagMap().get(mValueDescriptors.get(0).eventTag); } break; case EVENT_CHECK_SAME_VALUE: if (logParser != null) { chartDesc = String.format("%1$s / %2$s", logParser.getTagMap().get(mValueDescriptors.get(0).eventTag), mValueDescriptors.get(0).valueName); } break; } if (chartDesc != null) { return String.format("%1$s - %2$s", mName, chartDesc); } } return mName; } }