/*
* 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;
import com.android.ddmlib.log.EventContainer;
import com.android.ddmlib.log.EventContainer.CompareMethod;
import com.android.ddmlib.log.EventContainer.EventValueType;
import com.android.ddmlib.log.EventLogParser;
import com.android.ddmlib.log.EventValueDescription.ValueType;
import com.android.ddmlib.log.InvalidTypeException;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.event.ChartChangeEvent;
import org.jfree.chart.event.ChartChangeEventType;
import org.jfree.chart.event.ChartChangeListener;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.time.Millisecond;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.experimental.chart.swt.ChartComposite;
import org.jfree.experimental.swt.SWTUtils;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.regex.Pattern;
/**
* Represents a custom display of one or more events.
*/
abstract class EventDisplay {
private final static String DISPLAY_DATA_STORAGE_SEPARATOR = ":"; //$NON-NLS-1$
private final static String PID_STORAGE_SEPARATOR = ","; //$NON-NLS-1$
private final static String DESCRIPTOR_STORAGE_SEPARATOR = "$"; //$NON-NLS-1$
private final static String DESCRIPTOR_DATA_STORAGE_SEPARATOR = "!"; //$NON-NLS-1$
private final static String FILTER_VALUE_NULL = "<null>"; //$NON-NLS-1$
public final static int DISPLAY_TYPE_LOG_ALL = 0;
public final static int DISPLAY_TYPE_FILTERED_LOG = 1;
public final static int DISPLAY_TYPE_GRAPH = 2;
public final static int DISPLAY_TYPE_SYNC = 3;
public final static int DISPLAY_TYPE_SYNC_HIST = 4;
public final static int DISPLAY_TYPE_SYNC_PERF = 5;
private final static int EVENT_CHECK_FAILED = 0;
protected final static int EVENT_CHECK_SAME_TAG = 1;
protected final static int EVENT_CHECK_SAME_VALUE = 2;
/**
* Creates the appropriate EventDisplay subclass.
*
* @param type the type of display (DISPLAY_TYPE_LOG_ALL, etc)
* @param name the name of the display
* @return the created object
*/
public static EventDisplay eventDisplayFactory(int type, String name) {
switch (type) {
case DISPLAY_TYPE_LOG_ALL:
return new DisplayLog(name);
case DISPLAY_TYPE_FILTERED_LOG:
return new DisplayFilteredLog(name);
case DISPLAY_TYPE_SYNC:
return new DisplaySync(name);
case DISPLAY_TYPE_SYNC_HIST:
return new DisplaySyncHistogram(name);
case DISPLAY_TYPE_GRAPH:
return new DisplayGraph(name);
case DISPLAY_TYPE_SYNC_PERF:
return new DisplaySyncPerf(name);
default:
throw new InvalidParameterException("Unknown Display Type " + type); //$NON-NLS-1$
}
}
/**
* Adds event to the display.
* @param event The event
* @param logParser The log parser.
*/
abstract void newEvent(EventContainer event, EventLogParser logParser);
/**
* Resets the display.
*/
abstract void resetUI();
/**
* Gets display type
*
* @return display type as an integer
*/
abstract int getDisplayType();
/**
* 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).
*/
abstract Control createComposite(final Composite parent, EventLogParser logParser,
final ILogColumnListener listener);
interface ILogColumnListener {
void columnResized(int index, TableColumn sourceColumn);
}
/**
* Describes an event to be displayed.
*/
static class OccurrenceDisplayDescriptor {
int eventTag = -1;
int seriesValueIndex = -1;
boolean includePid = false;
int filterValueIndex = -1;
CompareMethod filterCompareMethod = CompareMethod.EQUAL_TO;
Object filterValue = null;
OccurrenceDisplayDescriptor() {
}
OccurrenceDisplayDescriptor(OccurrenceDisplayDescriptor descriptor) {
replaceWith(descriptor);
}
OccurrenceDisplayDescriptor(int eventTag) {
this.eventTag = eventTag;
}
OccurrenceDisplayDescriptor(int eventTag, int seriesValueIndex) {
this.eventTag = eventTag;
this.seriesValueIndex = seriesValueIndex;
}
void replaceWith(OccurrenceDisplayDescriptor descriptor) {
eventTag = descriptor.eventTag;
seriesValueIndex = descriptor.seriesValueIndex;
includePid = descriptor.includePid;
filterValueIndex = descriptor.filterValueIndex;
filterCompareMethod = descriptor.filterCompareMethod;
filterValue = descriptor.filterValue;
}
/**
* Loads the descriptor parameter from a storage string. The storage string must have
* been generated with {@link #getStorageString()}.
*
* @param storageString the storage string
*/
final void loadFrom(String storageString) {
String[] values = storageString.split(Pattern.quote(DESCRIPTOR_DATA_STORAGE_SEPARATOR));
loadFrom(values, 0);
}
/**
* Loads the parameters from an array of strings.
*
* @param storageStrings the strings representing each parameter.
* @param index the starting index in the array of strings.
* @return the new index in the array.
*/
protected int loadFrom(String[] storageStrings, int index) {
eventTag = Integer.parseInt(storageStrings[index++]);
seriesValueIndex = Integer.parseInt(storageStrings[index++]);
includePid = Boolean.parseBoolean(storageStrings[index++]);
filterValueIndex = Integer.parseInt(storageStrings[index++]);
try {
filterCompareMethod = CompareMethod.valueOf(storageStrings[index++]);
} catch (IllegalArgumentException e) {
// if the name does not match any known CompareMethod, we init it to the default one
filterCompareMethod = CompareMethod.EQUAL_TO;
}
String value = storageStrings[index++];
if (filterValueIndex != -1 && FILTER_VALUE_NULL.equals(value) == false) {
filterValue = EventValueType.getObjectFromStorageString(value);
}
return index;
}
/**
* Returns the storage string for the receiver.
*/
String getStorageString() {
StringBuilder sb = new StringBuilder();
sb.append(eventTag);
sb.append(DESCRIPTOR_DATA_STORAGE_SEPARATOR);
sb.append(seriesValueIndex);
sb.append(DESCRIPTOR_DATA_STORAGE_SEPARATOR);
sb.append(Boolean.toString(includePid));
sb.append(DESCRIPTOR_DATA_STORAGE_SEPARATOR);
sb.append(filterValueIndex);
sb.append(DESCRIPTOR_DATA_STORAGE_SEPARATOR);
sb.append(filterCompareMethod.name());
sb.append(DESCRIPTOR_DATA_STORAGE_SEPARATOR);
if (filterValue != null) {
String value = EventValueType.getStorageString(filterValue);
if (value != null) {
sb.append(value);
} else {
sb.append(FILTER_VALUE_NULL);
}
} else {
sb.append(FILTER_VALUE_NULL);
}
return sb.toString();
}
}
/**
* Describes an event value to be displayed.
*/
static final class ValueDisplayDescriptor extends OccurrenceDisplayDescriptor {
String valueName;
int valueIndex = -1;
ValueDisplayDescriptor() {
super();
}
ValueDisplayDescriptor(ValueDisplayDescriptor descriptor) {
super();
replaceWith(descriptor);
}
ValueDisplayDescriptor(int eventTag, String valueName, int valueIndex) {
super(eventTag);
this.valueName = valueName;
this.valueIndex = valueIndex;
}
ValueDisplayDescriptor(int eventTag, String valueName, int valueIndex,
int seriesValueIndex) {
super(eventTag, seriesValueIndex);
this.valueName = valueName;
this.valueIndex = valueIndex;
}
@Override
void replaceWith(OccurrenceDisplayDescriptor descriptor) {
super.replaceWith(descriptor);
if (descriptor instanceof ValueDisplayDescriptor) {
ValueDisplayDescriptor valueDescriptor = (ValueDisplayDescriptor) descriptor;
valueName = valueDescriptor.valueName;
valueIndex = valueDescriptor.valueIndex;
}
}
/**
* Loads the parameters from an array of strings.
*
* @param storageStrings the strings representing each parameter.
* @param index the starting index in the array of strings.
* @return the new index in the array.
*/
@Override
protected int loadFrom(String[] storageStrings, int index) {
index = super.loadFrom(storageStrings, index);
valueName = storageStrings[index++];
valueIndex = Integer.parseInt(storageStrings[index++]);
return index;
}
/**
* Returns the storage string for the receiver.
*/
@Override
String getStorageString() {
String superStorage = super.getStorageString();
StringBuilder sb = new StringBuilder();
sb.append(superStorage);
sb.append(DESCRIPTOR_DATA_STORAGE_SEPARATOR);
sb.append(valueName);
sb.append(DESCRIPTOR_DATA_STORAGE_SEPARATOR);
sb.append(valueIndex);
return sb.toString();
}
}
/* ==================
* Event Display parameters.
* ================== */
protected String mName;
private boolean mPidFiltering = false;
private ArrayList<Integer> mPidFilterList = null;
protected final ArrayList<ValueDisplayDescriptor> mValueDescriptors =
new ArrayList<ValueDisplayDescriptor>();
private final ArrayList<OccurrenceDisplayDescriptor> mOccurrenceDescriptors =
new ArrayList<OccurrenceDisplayDescriptor>();
/* ==================
* Event Display members for display purpose.
* ================== */
// chart objects
/**
* This is a map of (descriptor, map2) where map2 is a map of (pid, chart-series)
*/
protected final HashMap<ValueDisplayDescriptor, HashMap<Integer, TimeSeries>> mValueDescriptorSeriesMap =
new HashMap<ValueDisplayDescriptor, HashMap<Integer, TimeSeries>>();
/**
* This is a map of (descriptor, map2) where map2 is a map of (pid, chart-series)
*/
protected final HashMap<OccurrenceDisplayDescriptor, HashMap<Integer, TimeSeries>> mOcurrenceDescriptorSeriesMap =
new HashMap<OccurrenceDisplayDescriptor, HashMap<Integer, TimeSeries>>();
/**
* This is a map of (ValueType, dataset)
*/
protected final HashMap<ValueType, TimeSeriesCollection> mValueTypeDataSetMap =
new HashMap<ValueType, TimeSeriesCollection>();
protected JFreeChart mChart;
protected TimeSeriesCollection mOccurrenceDataSet;
protected int mDataSetCount;
private ChartComposite mChartComposite;
protected long mMaximumChartItemAge = -1;
protected long mHistWidth = 1;
// log objects.
protected Table mLogTable;
/* ==================
* Misc data.
* ================== */
protected int mValueDescriptorCheck = EVENT_CHECK_FAILED;
EventDisplay(String name) {
mName = name;
}
static EventDisplay clone(EventDisplay from) {
EventDisplay ed = eventDisplayFactory(from.getDisplayType(), from.getName());
ed.mName = from.mName;
ed.mPidFiltering = from.mPidFiltering;
ed.mMaximumChartItemAge = from.mMaximumChartItemAge;
ed.mHistWidth = from.mHistWidth;
if (from.mPidFilterList != null) {
ed.mPidFilterList = new ArrayList<Integer>();
ed.mPidFilterList.addAll(from.mPidFilterList);
}
for (ValueDisplayDescriptor desc : from.mValueDescriptors) {
ed.mValueDescriptors.add(new ValueDisplayDescriptor(desc));
}
ed.mValueDescriptorCheck = from.mValueDescriptorCheck;
for (OccurrenceDisplayDescriptor desc : from.mOccurrenceDescriptors) {
ed.mOccurrenceDescriptors.add(new OccurrenceDisplayDescriptor(desc));
}
return ed;
}
/**
* Returns the parameters of the receiver as a single String for storage.
*/
String getStorageString() {
StringBuilder sb = new StringBuilder();
sb.append(mName);
sb.append(DISPLAY_DATA_STORAGE_SEPARATOR);
sb.append(getDisplayType());
sb.append(DISPLAY_DATA_STORAGE_SEPARATOR);
sb.append(Boolean.toString(mPidFiltering));
sb.append(DISPLAY_DATA_STORAGE_SEPARATOR);
sb.append(getPidStorageString());
sb.append(DISPLAY_DATA_STORAGE_SEPARATOR);
sb.append(getDescriptorStorageString(mValueDescriptors));
sb.append(DISPLAY_DATA_STORAGE_SEPARATOR);
sb.append(getDescriptorStorageString(mOccurrenceDescriptors));
sb.append(DISPLAY_DATA_STORAGE_SEPARATOR);
sb.append(mMaximumChartItemAge);
sb.append(DISPLAY_DATA_STORAGE_SEPARATOR);
sb.append(mHistWidth);
sb.append(DISPLAY_DATA_STORAGE_SEPARATOR);
return sb.toString();
}
void setName(String name) {
mName = name;
}
String getName() {
return mName;
}
void setPidFiltering(boolean filterByPid) {
mPidFiltering = filterByPid;
}
boolean getPidFiltering() {
return mPidFiltering;
}
void setPidFilterList(ArrayList<Integer> pids) {
if (mPidFiltering == false) {
new InvalidParameterException();
}
mPidFilterList = pids;
}
ArrayList<Integer> getPidFilterList() {
return mPidFilterList;
}
void addPidFiler(int pid) {
if (mPidFiltering == false) {
new InvalidParameterException();
}
if (mPidFilterList == null) {
mPidFilterList = new ArrayList<Integer>();
}
mPidFilterList.add(pid);
}
/**
* Returns an iterator to the list of {@link ValueDisplayDescriptor}.
*/
Iterator<ValueDisplayDescriptor> getValueDescriptors() {
return mValueDescriptors.iterator();
}
/**
* Update checks on the descriptors. Must be called whenever a descriptor is modified outside
* of this class.
*/
void updateValueDescriptorCheck() {
mValueDescriptorCheck = checkDescriptors();
}
/**
* Returns an iterator to the list of {@link OccurrenceDisplayDescriptor}.
*/
Iterator<OccurrenceDisplayDescriptor> getOccurrenceDescriptors() {
return mOccurrenceDescriptors.iterator();
}
/**
* Adds a descriptor. This can be a {@link OccurrenceDisplayDescriptor} or a
* {@link ValueDisplayDescriptor}.
*
* @param descriptor the descriptor to be added.
*/
void addDescriptor(OccurrenceDisplayDescriptor descriptor) {
if (descriptor instanceof ValueDisplayDescriptor) {
mValueDescriptors.add((ValueDisplayDescriptor) descriptor);
mValueDescriptorCheck = checkDescriptors();
} else {
mOccurrenceDescriptors.add(descriptor);
}
}
/**
* Returns a descriptor by index and class (extending {@link OccurrenceDisplayDescriptor}).
*
* @param descriptorClass the class of the descriptor to return.
* @param index the index of the descriptor to return.
* @return either a {@link OccurrenceDisplayDescriptor} or a {@link ValueDisplayDescriptor}
* or <code>null</code> if <code>descriptorClass</code> is another class.
*/
OccurrenceDisplayDescriptor getDescriptor(
Class<? extends OccurrenceDisplayDescriptor> descriptorClass, int index) {
if (descriptorClass == OccurrenceDisplayDescriptor.class) {
return mOccurrenceDescriptors.get(index);
} else if (descriptorClass == ValueDisplayDescriptor.class) {
return mValueDescriptors.get(index);
}
return null;
}
/**
* Removes a descriptor based on its class and index.
*
* @param descriptorClass the class of the descriptor.
* @param index the index of the descriptor to be removed.
*/
void removeDescriptor(Class<? extends OccurrenceDisplayDescriptor> descriptorClass, int index) {
if (descriptorClass == OccurrenceDisplayDescriptor.class) {
mOccurrenceDescriptors.remove(index);
} else if (descriptorClass == ValueDisplayDescriptor.class) {
mValueDescriptors.remove(index);
mValueDescriptorCheck = checkDescriptors();
}
}
Control createCompositeChart(final Composite parent, EventLogParser logParser,
String title) {
mChart = ChartFactory.createTimeSeriesChart(
null,
null /* timeAxisLabel */,
null /* valueAxisLabel */,
null, /* dataset. set below */
true /* legend */,
false /* tooltips */,
false /* urls */);
// get the font to make a proper title. We need to convert the swt font,
// into an awt font.
Font f = parent.getFont();
FontData[] fData = f.getFontData();
// event though on Mac OS there could be more than one fontData, we'll only use
// the first one.
FontData firstFontData = fData[0];
java.awt.Font awtFont = SWTUtils.toAwtFont(parent.getDisplay(),
firstFontData, true /* ensureSameSize */);
mChart.setTitle(new TextTitle(title, awtFont));
final XYPlot xyPlot = mChart.getXYPlot();
xyPlot.setRangeCrosshairVisible(true);
xyPlot.setRangeCrosshairLockedOnData(true);
xyPlot.setDomainCrosshairVisible(true);
xyPlot.setDomainCrosshairLockedOnData(true);
mChart.addChangeListener(new ChartChangeListener() {
public void chartChanged(ChartChangeEvent event) {
ChartChangeEventType type = event.getType();
if (type == ChartChangeEventType.GENERAL) {
// because the value we need (rangeCrosshair and domainCrosshair) are
// updated on the draw, but the notification happens before the draw,
// we process the click in a future runnable!
parent.getDisplay().asyncExec(new Runnable() {
public void run() {
processClick(xyPlot);
}
});
}
}
});
mChartComposite = new ChartComposite(parent, SWT.BORDER, mChart,
ChartComposite.DEFAULT_WIDTH,
ChartComposite.DEFAULT_HEIGHT,
ChartComposite.DEFAULT_MINIMUM_DRAW_WIDTH,
ChartComposite.DEFAULT_MINIMUM_DRAW_HEIGHT,
3000, // max draw width. We don't want it to zoom, so we put a big number
3000, // max draw height. We don't want it to zoom, so we put a big number
true, // off-screen buffer
true, // properties
true, // save
true, // print
true, // zoom
true); // tooltips
mChartComposite.addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
mValueTypeDataSetMap.clear();
mDataSetCount = 0;
mOccurrenceDataSet = null;
mChart = null;
mChartComposite = null;
mValueDescriptorSeriesMap.clear();
mOcurrenceDescriptorSeriesMap.clear();
}
});
return mChartComposite;
}
private void processClick(XYPlot xyPlot) {
double rangeValue = xyPlot.getRangeCrosshairValue();
if (rangeValue != 0) {
double domainValue = xyPlot.getDomainCrosshairValue();
Millisecond msec = new Millisecond(new Date((long) domainValue));
// look for values in the dataset that contains data at this TimePeriod
Set<ValueDisplayDescriptor> descKeys = mValueDescriptorSeriesMap.keySet();
for (ValueDisplayDescriptor descKey : descKeys) {
HashMap<Integer, TimeSeries> map = mValueDescriptorSeriesMap.get(descKey);
Set<Integer> pidKeys = map.keySet();
for (Integer pidKey : pidKeys) {
TimeSeries series = map.get(pidKey);
Number value = series.getValue(msec);
if (value != null) {
// found a match. lets check against the actual value.
if (value.doubleValue() == rangeValue) {
return;
}
}
}
}
}
}
/**
* Resizes the <code>index</code>-th column of the log {@link Table} (if applicable).
* Subclasses can override if necessary.
* <p/>
* This does nothing if the <code>Table</code> object is <code>null</code> (because the display
* type does not use a column) or if the <code>index</code>-th column is in fact the originating
* column passed as argument.
*
* @param index the index of the column to resize
* @param sourceColumn the original column that was resize, and on which we need to sync the
* index-th column width.
*/
void resizeColumn(int index, TableColumn sourceColumn) {
}
/**
* Sets the current {@link EventLogParser} object.
* Subclasses can override if necessary.
*/
protected void setNewLogParser(EventLogParser logParser) {
}
/**
* Prepares the {@link EventDisplay} for a multi event display.
*/
void startMultiEventDisplay() {
if (mLogTable != null) {
mLogTable.setRedraw(false);
}
}
/**
* Finalizes the {@link EventDisplay} after a multi event display.
*/
void endMultiEventDisplay() {
if (mLogTable != null) {
mLogTable.setRedraw(true);
}
}
/**
* Returns the {@link Table} object used to display events, if any.
*
* @return a Table object or <code>null</code>.
*/
Table getTable() {
return mLogTable;
}
/**
* Loads a new {@link EventDisplay} from a storage string. The string must have been created
* with {@link #getStorageString()}.
*
* @param storageString the storage string
* @return a new {@link EventDisplay} or null if the load failed.
*/
static EventDisplay load(String storageString) {
if (storageString.length() > 0) {
// the storage string is separated by ':'
String[] values = storageString.split(Pattern.quote(DISPLAY_DATA_STORAGE_SEPARATOR));
try {
int index = 0;
String name = values[index++];
int displayType = Integer.parseInt(values[index++]);
boolean pidFiltering = Boolean.parseBoolean(values[index++]);
EventDisplay ed = eventDisplayFactory(displayType, name);
ed.setPidFiltering(pidFiltering);
// because empty sections are removed by String.split(), we have to check
// the index for those.
if (index < values.length) {
ed.loadPidFilters(values[index++]);
}
if (index < values.length) {
ed.loadValueDescriptors(values[index++]);
}
if (index < values.length) {
ed.loadOccurrenceDescriptors(values[index++]);
}
ed.updateValueDescriptorCheck();
if (index < values.length) {
ed.mMaximumChartItemAge = Long.parseLong(values[index++]);
}
if (index < values.length) {
ed.mHistWidth = Long.parseLong(values[index++]);
}
return ed;
} catch (RuntimeException re) {
// we'll return null below.
Log.e("ddms", re);
}
}
return null;
}
private String getPidStorageString() {
if (mPidFilterList != null) {
StringBuilder sb = new StringBuilder();
boolean first = true;
for (Integer i : mPidFilterList) {
if (first == false) {
sb.append(PID_STORAGE_SEPARATOR);
} else {
first = false;
}
sb.append(i);
}
return sb.toString();
}
return ""; //$NON-NLS-1$
}
private void loadPidFilters(String storageString) {
if (storageString.length() > 0) {
String[] values = storageString.split(Pattern.quote(PID_STORAGE_SEPARATOR));
for (String value : values) {
if (mPidFilterList == null) {
mPidFilterList = new ArrayList<Integer>();
}
mPidFilterList.add(Integer.parseInt(value));
}
}
}
private String getDescriptorStorageString(
ArrayList<? extends OccurrenceDisplayDescriptor> descriptorList) {
StringBuilder sb = new StringBuilder();
boolean first = true;
for (OccurrenceDisplayDescriptor descriptor : descriptorList) {
if (first == false) {
sb.append(DESCRIPTOR_STORAGE_SEPARATOR);
} else {
first = false;
}
sb.append(descriptor.getStorageString());
}
return sb.toString();
}
private void loadOccurrenceDescriptors(String storageString) {
if (storageString.length() == 0) {
return;
}
String[] values = storageString.split(Pattern.quote(DESCRIPTOR_STORAGE_SEPARATOR));
for (String value : values) {
OccurrenceDisplayDescriptor desc = new OccurrenceDisplayDescriptor();
desc.loadFrom(value);
mOccurrenceDescriptors.add(desc);
}
}
private void loadValueDescriptors(String storageString) {
if (storageString.length() == 0) {
return;
}
String[] values = storageString.split(Pattern.quote(DESCRIPTOR_STORAGE_SEPARATOR));
for (String value : values) {
ValueDisplayDescriptor desc = new ValueDisplayDescriptor();
desc.loadFrom(value);
mValueDescriptors.add(desc);
}
}
/**
* Fills a list with {@link OccurrenceDisplayDescriptor} (or a subclass of it) from another
* list if they are configured to display the {@link EventContainer}
*
* @param event the event container
* @param fullList the list with all the descriptors.
* @param outList the list to fill.
*/
@SuppressWarnings("unchecked")
private void getDescriptors(EventContainer event,
ArrayList<? extends OccurrenceDisplayDescriptor> fullList,
ArrayList outList) {
for (OccurrenceDisplayDescriptor descriptor : fullList) {
try {
// first check the event tag.
if (descriptor.eventTag == event.mTag) {
// now check if we have a filter on a value
if (descriptor.filterValueIndex == -1 ||
event.testValue(descriptor.filterValueIndex, descriptor.filterValue,
descriptor.filterCompareMethod)) {
outList.add(descriptor);
}
}
} catch (InvalidTypeException ite) {
// if the filter for the descriptor was incorrect, we ignore the descriptor.
} catch (ArrayIndexOutOfBoundsException aioobe) {
// if the index was wrong (the event content may have changed since we setup the
// display), we do nothing but log the error
Log.e("Event Log", String.format(
"ArrayIndexOutOfBoundsException occured when checking %1$d-th value of event %2$d", //$NON-NLS-1$
descriptor.filterValueIndex, descriptor.eventTag));
}
}
}
/**
* Filters the {@link com.android.ddmlib.log.EventContainer}, and fills two list of {@link com.android.ddmuilib.log.event.EventDisplay.ValueDisplayDescriptor}
* and {@link com.android.ddmuilib.log.event.EventDisplay.OccurrenceDisplayDescriptor} configured to display the event.
*
* @param event
* @param valueDescriptors
* @param occurrenceDescriptors
* @return true if the event should be displayed.
*/
protected boolean filterEvent(EventContainer event,
ArrayList<ValueDisplayDescriptor> valueDescriptors,
ArrayList<OccurrenceDisplayDescriptor> occurrenceDescriptors) {
// test the pid first (if needed)
if (mPidFiltering && mPidFilterList != null) {
boolean found = false;
for (int pid : mPidFilterList) {
if (pid == event.pid) {
found = true;
break;
}
}
if (found == false) {
return false;
}
}
// now get the list of matching descriptors
getDescriptors(event, mValueDescriptors, valueDescriptors);
getDescriptors(event, mOccurrenceDescriptors, occurrenceDescriptors);
// and return whether there is at least one match in either list.
return (valueDescriptors.size() > 0 || occurrenceDescriptors.size() > 0);
}
/**
* Checks all the {@link ValueDisplayDescriptor} for similarity.
* If all the event values are from the same tag, the method will return EVENT_CHECK_SAME_TAG.
* If all the event/value are the same, the method will return EVENT_CHECK_SAME_VALUE
*
* @return flag as described above
*/
private int checkDescriptors() {
if (mValueDescriptors.size() < 2) {
return EVENT_CHECK_SAME_VALUE;
}
int tag = -1;
int index = -1;
for (ValueDisplayDescriptor display : mValueDescriptors) {
if (tag == -1) {
tag = display.eventTag;
index = display.valueIndex;
} else {
if (tag != display.eventTag) {
return EVENT_CHECK_FAILED;
} else {
if (index != -1) {
if (index != display.valueIndex) {
index = -1;
}
}
}
}
}
if (index == -1) {
return EVENT_CHECK_SAME_TAG;
}
return EVENT_CHECK_SAME_VALUE;
}
/**
* Resets the time limit on the chart to be infinite.
*/
void resetChartTimeLimit() {
mMaximumChartItemAge = -1;
}
/**
* Sets the time limit on the charts.
*
* @param timeLimit the time limit in seconds.
*/
void setChartTimeLimit(long timeLimit) {
mMaximumChartItemAge = timeLimit;
}
long getChartTimeLimit() {
return mMaximumChartItemAge;
}
/**
* m
* Resets the histogram width
*/
void resetHistWidth() {
mHistWidth = 1;
}
/**
* Sets the histogram width
*
* @param histWidth the width in hours
*/
void setHistWidth(long histWidth) {
mHistWidth = histWidth;
}
long getHistWidth() {
return mHistWidth;
}
}
|
