"dialog_contents_normal_font", resizeDefaultFont(8, 3));//$NON-NLS-1$
public static final Font ABOUT_DIALOG_TITLE_BIG_FONT = getFont(
- "about_dialog_title_big_font", new FontData[] { new FontData("Arial", 20, SWT.BOLD) });//$NON-NLS-1$
+ "about_dialog_title_big_font", new FontData[] { new FontData("BreezeS", 23, SWT.BOLD) });//$NON-NLS-1$
public static final Font ABOUT_DIALOG_TITLE_BIG_FONT_MAC = getFont(
"about_dialog_title_big_font_mac", new FontData[] { new FontData("BreezeS", 23, SWT.BOLD) });//$NON-NLS-1$
public static final Font ABOUT_DIALOG_TITLE_MIDDLE_FONT = getFont(
- "about_dialog_title_middle_font", new FontData[] { new FontData("Arial", 10, SWT.NORMAL) });//$NON-NLS-1$
+ "about_dialog_title_middle_font", new FontData[] { new FontData("BreezeS", 12, SWT.NORMAL) });//$NON-NLS-1$
public static final Font ABOUT_DIALOG_TITLE_MIDDLE_FONT_MAC = getFont(
"about_dialog_title_middle_font_mac", new FontData[] { new FontData("BreezeS", 13, SWT.NORMAL) });//$NON-NLS-1$
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
-import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Text;
import org.tizen.dynamicanalyzer.resources.ColorResources;
public void paintControl(PaintEvent e) {
e.gc.setForeground(boaderColor);
Text text = (Text) e.widget;
- Rectangle rect = text.getClientArea();
- e.gc.drawRectangle(rect.x, rect.y, rect.width - 1,
- rect.height - 1);
+ Point size = text.getSize();
+ e.gc.drawRectangle(0, 0, size.x - 1, size.y - 1);
}
});
// Initialize SettingDataManager
String selectedTarget = SettingDataManager.INSTANCE
- .getConnectedTarget().getTargetName();
+ .getConnectedTargetOrSelected().getTargetName();
SettingDataManager.INSTANCE.setSelectedTarget(selectedTarget);
}
target.setSelectedFlatFeatures(new HashSet<FlatFeature>());
selectScreenshotFeature(args.getScreenshotPeriod(),
- args.isScreenshotPeriodSpecified());
+ args.getScreenshotOnSceneTransition());
args.getFeatures().remove(PrimitiveFeature.SCREENSHOT);//This feature added to target by selectScreenshotFeature().
for (PrimitiveFeature feature : args.getFeatures()) {
/**
* Enables screenshot onSceneTransition or periodically.
*
- * @param period period in seconds, onSceneTransition if period == 0.
- * @return was operation successful or not.
+ * @param period period in seconds
+ * @param onSceneTransition enable on scene transition or not
*/
private static void selectScreenshotFeature(int period,
- boolean isScreenshotsEnabled) {
+ boolean onSceneTransition) {
// TODO move this to common place for CLI and GUI
- if (!isScreenshotsEnabled) {
+ if ((!onSceneTransition) && (period <= 0)) {
Logger.debug("Screenshots are not captured.");
return;
}
- if (period == 0){
- TargetData target = SettingDataManager.INSTANCE.getTarget(null);
- target.addSelectedFlatFeature(ConfigureLabels.FEATURE_NAME_SCREENSHOT);
+ TargetData target = SettingDataManager.INSTANCE.getTarget(null);
+ target.addSelectedFlatFeature(ConfigureLabels.FEATURE_NAME_SCREENSHOT);
+ if (onSceneTransition) {
+ SettingDataManager.INSTANCE.addOptionsSelectedPreference(
+ FlatPreferences.SCREENSHOT_ON_SCENE_TRANSITION, 1);
Logger.debug("Screenshots are captured on scene transition.");
+ } else {
+ SettingDataManager.INSTANCE
+ .deleteOptionsSelectedPreference(FlatPreferences.SCREENSHOT_ON_SCENE_TRANSITION);
}
if (period > 0){
SettingDataManager.INSTANCE.addOptionsSelectedPreference(
FlatPreferences.SCREENSHOT_PERIODICALLY, period);
Logger.debug("Screenshots are captured every " + period + " sec.");
+ } else {
+ SettingDataManager.INSTANCE
+ .deleteOptionsSelectedPreference(FlatPreferences.SCREENSHOT_PERIODICALLY);
}
UILayoutDataManager.INSTANCE
.addSelectedChart(TimelineChartLabels.SCREENSHOT_CHART_TITLE);
static int TRACING_PROCESS_STOP_TIMEOUT = 16000; // TODO measure this timeout more accurate later
/**
- * Value to start port enumeration
- */
- public static final int DEFAULT_PORT = 9000;
- /**
* Map between device and last trace manager used for that device.
*/
Map<String, TracingProcessManager> mTracingMap;
return new DAResult(ErrorCode.ERR_BUSY_DEVICE);
}
- int port = DEFAULT_PORT + mTracingMap.size();
final TracingProcessManager tpManager;
try {
- tpManager = TracingProcessManager.createTracingProcess(args, port);
+ tpManager = TracingProcessManager.createTracingProcess(args);
} catch (IOException e) {
Logger.error("Couldn't start tracing proccess: %s.", e.toString());
return new DAResult(ErrorCode.ERR_EXCEPTION_OCCURRED, "Couldn't start tracing process: " + e.toString());
* Execute new tracing process with specified arguments and wrap it with {@link TracingProcessManager}.
*
* @param args tracing arguments
- * @param port integer socket port number
* @return {@link TracingProcessManager} instance that manages corresponding process.
* @throws IOException in error occurred while executing process
*/
- public static TracingProcessManager createTracingProcess(TracingArguments args, int port) throws IOException {
+ public static TracingProcessManager createTracingProcess(
+ TracingArguments args) throws IOException {
// compose command line
String currentClasspath = System.getProperty("java.class.path");
// send communication port number to tracing process
bw = new BufferedWriter(new OutputStreamWriter(
process.getOutputStream(), StandardCharsets.UTF_8));
+ ServerSocket ss = getServerSocket();
try {
- bw.write(Integer.toString(port));
+ bw.write(Integer.toString(ss.getLocalPort()));
bw.newLine();
bw.flush();
} catch (IOException e2) {
}
- return new TracingProcessManager(args, process, port);
+ return new TracingProcessManager(args, process, ss);
+ }
+
+ /**
+ * Method allocates available local socket.
+ *
+ * @return ServerSocket instance with free port.
+ */
+ private static ServerSocket getServerSocket() {
+ while (true) {
+ try {
+ ServerSocket ss = new ServerSocket(0);
+ return ss;
+ } catch (IOException e) {
+ }
+ }
}
/**
}
/**
- * Private constructor.
- * Instances should be created via {@link #createTracingProcess(TracingArguments)}.
+ * Private constructor. Instances should be created via
+ * {@link #createTracingProcess(TracingArguments)}.
*
* @param args arguments with which tracing process started
* @param process process instance corresponding to the tracing process
- * @param port integer socket port number
+ * @param ss ServerSocket to start communication
*/
private TracingProcessManager(TracingArguments args, Process process,
- int port) {
+ ServerSocket ss) {
ctx = new TracingProcessContext(args);
tracingProcess = process;
try {
- final ServerSocket ss = new ServerSocket(port);
Socket socket = ss.accept();
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.flush();
private String output; // absolute path to file with tracing output
// TODO duration actually is not supported yet by CLI, always set to 0
private long durationSec; // tracing duration in seconds (0 is for unlimited duration)
- private int screenshotPeriod = 0; // Screenshot period in s. If 0
- // onSceneTransition else periodically
- private boolean isScreenshotPeriodSpecified = false;
+ private int screenshotPeriod = 0; // Screenshot period in seconds
+ private boolean screenshotOnSceneTransition = false;// take screenshots on scene transition or not
private String errMessage; // contains message about all found errors during validation ( isValid() )
}
// Screenshot period check
- if (isScreenshotPeriodSpecified) {
- if (screenshotPeriod < 0) {
- result = false;
- msg += " * Screenshot period is negative%n";
- }
+ if (screenshotPeriod < 0) {
+ result = false;
+ msg += " * Screenshot period is negative%n";
}
// Features check
}
/**
- * @return <code>true</code> if screenshots enabled.
- */
- public boolean isScreenshotPeriodSpecified() {
- return isScreenshotPeriodSpecified;
- }
-
- /**
* @param period The period in seconds to set. 0 for onSceneTransition.
* @return this object to allow chained methods execution
*/
public TracingArguments setScreenshotPeriod(int period) {
this.screenshotPeriod = period;
- this.isScreenshotPeriodSpecified = true;
this.featuresSet.add(PrimitiveFeature.SCREENSHOT);
return this;
}
/**
+ * @return <code>true</code> if screenshots on scene transition enabled.
+ */
+ public boolean getScreenshotOnSceneTransition() {
+ return screenshotOnSceneTransition;
+ }
+
+ /**
+ * @param flag enable On Scene Transition screenshot capturing or not
+ * @return this object to allow chained methods execution
+ */
+ public TracingArguments setScreenshotOnSceneTransition(boolean flag) {
+ this.screenshotOnSceneTransition = flag;
+ if (flag)
+ this.featuresSet.add(PrimitiveFeature.SCREENSHOT);
+ return this;
+ }
+
+ /**
* @return the featuresList list of features selected for tracing
*/
public Set<PrimitiveFeature> getFeatures() {
private static Option screenshotPeriod = Option.builder("S")
.hasArg()
- .optionalArg(true)
- .longOpt("screenshot")
- .argName("screenshot")
- .desc("Enable screenshots capturing periodically or on scene transition if no argument set")
+ .argName("period")
+ .desc("Enable screenshots capturing periodically").build();
+
+ private static Option screenshotTransition = Option.builder("s")
+ .desc("Enable screenshots capturing on scene transition")
.build();
private static Options opts = new Options();
opts.addOption(featureOpt.getOption());
}
opts.addOption(screenshotPeriod);
+ opts.addOption(screenshotTransition);
}
/**
// Get screenshot period
if (cmdline.hasOption(screenshotPeriod.getOpt())) {
String period = cmdline.getOptionValue(screenshotPeriod.getOpt());
- if (period == null) {
- result.setScreenshotPeriod(0);
- } else {
+ if (period != null) {
try{
int periodInt = Integer.parseInt(period);
+ if (periodInt < 0)
+ throw new NumberFormatException();
result.setScreenshotPeriod(periodInt);
}catch(NumberFormatException nfe){
throw new ParseException(
}
}
+ // Get on scene transition screenshot
+ if (cmdline.hasOption(screenshotTransition.getOpt())) {
+ result.setScreenshotOnSceneTransition(true);
+ }
+
// Get features
TracingFeatureArgument.parseFeatureOptions(result, cmdline);
result.add(out);
}
+ // screenshot on scene transition
+ if (args.getScreenshotOnSceneTransition())
+ result.add('-' + screenshotTransition.getOpt());
+
+ // screenshot periodically
int period = args.getScreenshotPeriod();
- if (args.isScreenshotPeriodSpecified()) {
+ if (period > 0) {
result.add('-' + screenshotPeriod.getOpt());
- if (period > 0)
- result.add(Integer.toString(period));
+ result.add(Integer.toString(period));
}
// Features
import org.apache.commons.cli.ParseException;
import org.tizen.dynamicanalyzer.cli.CliInternals;
import org.tizen.dynamicanalyzer.cli.commands.ExitCode;
-import org.tizen.dynamicanalyzer.cli.manager.ProcessManager;
import org.tizen.dynamicanalyzer.cli.utils.Communicator;
import org.tizen.dynamicanalyzer.cli.utils.ProcessCommunicationProcessor;
import org.tizen.dynamicanalyzer.common.DAResult.ErrorCode;
} catch (NumberFormatException | IOException e) {
System.exit(ExitCode.EX_CONNECTION_ERROR.getCode());
}
- return ProcessManager.DEFAULT_PORT;
+ // unreachable instruction
+ return 0;
}
/**
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.tizen.dynamicanalyzer.setting.PrimitiveFeature;
import org.tizen.dynamicanalyzer.util.InternalLogger;
import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.sdblib.IDevice;
/**
* Test ProcessManager behavior.
private void setupManagers() throws Exception {
PowerMockito
- .when(TracingProcessManager.createTracingProcess(eq(args1),
- anyInt())).thenReturn(mgr1);
+ .when(TracingProcessManager.createTracingProcess(args1))
+ .thenReturn(mgr1);
Mockito.when(mgr1.getContext()).thenReturn(ctx1);
Mockito.when(mgr1.isFinished()).thenReturn(false);
PowerMockito
- .when(TracingProcessManager.createTracingProcess(eq(args2),
- anyInt())).thenReturn(mgr2);
+ .when(TracingProcessManager.createTracingProcess(args2))
+ .thenReturn(mgr2);
Mockito.when(mgr2.getContext()).thenReturn(ctx2);
Mockito.when(mgr2.isFinished()).thenReturn(false);
- IDevice mockDevice = mock(IDevice.class);
PowerMockito.when(CliInternals.isDeviceExist(args2.getDevice()))
.thenReturn(true);
assertEquals(ErrorCode.SUCCESS.getErrorNumber(), result.getErrorNumber());
PowerMockito.verifyStatic();
- TracingProcessManager.createTracingProcess(args1, 9000);
+ TracingProcessManager.createTracingProcess(args1);
assertEquals(ctx1, pm.getContext(args1.getDevice()));
}
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.net.InetAddress;
+import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.concurrent.Callable;
import org.tizen.dynamicanalyzer.cli.tracing.TracingArguments;
import org.tizen.dynamicanalyzer.cli.utils.Message;
import org.tizen.dynamicanalyzer.cli.utils.Message.MessageType;
+import org.tizen.dynamicanalyzer.cli.utils.OppositeCommSide;
import org.tizen.dynamicanalyzer.setting.PrimitiveFeature;
import org.tizen.dynamicanalyzer.util.InternalLogger;
import org.tizen.dynamicanalyzer.util.Logger;
static ObjectInputStream ois;
- static final int port = 9000;
+ static ServerSocket ss = OppositeCommSide.getServerSocket();
/**
* Base time unit used in some test for sleep and timeout.
*/
args.setDuration(0);
args.addFeature(PrimitiveFeature.CPU_USAGE);
- managerConstructor = Whitebox.getConstructor(TracingProcessManager.class, TracingArguments.class, Process.class, int.class);
+ managerConstructor = Whitebox.getConstructor(
+ TracingProcessManager.class, TracingArguments.class,
+ Process.class, ServerSocket.class);
}
/**
commThread.start();
// create class under test
- manager = managerConstructor.newInstance(args, process, port);
+ manager = managerConstructor.newInstance(args, process, ss);
ctx = manager.getContext();
assertFalse(manager.isFinished());
public void stopTracing_no_except() throws Exception {
commThread.start();
// create class under test
- manager = managerConstructor.newInstance(args, process, port);
+ manager = managerConstructor.newInstance(args, process, ss);
manager.stopTracing();
assertEquals(MessageType.REQUEST__STOP_TRACING,
});
// create class under test
- manager = managerConstructor.newInstance(args, process, port);
+ manager = managerConstructor.newInstance(args, process, ss);
// synchronization barrier
while (!reached) {
});
commThread.start();
// create class under test
- manager = managerConstructor.newInstance(args, process, port);
+ manager = managerConstructor.newInstance(args, process, ss);
assertFalse(manager.isFinished());
assertCurrentTime(manager.getContext().getStartTime().getTime());
});
// create class under test
- manager = managerConstructor.newInstance(args, process, port);
+ manager = managerConstructor.newInstance(args, process, ss);
assertFalse(manager.isFinished());
assertCurrentTime(manager.getContext().getStartTime().getTime());
}).when(process).destroy();
// create class under test
- manager = managerConstructor.newInstance(args, process, port);
+ manager = managerConstructor.newInstance(args, process, ss);
assertFalse(manager.isFinished());
assertCurrentTime(manager.getContext().getStartTime().getTime());
});
// create class under test
- manager = managerConstructor.newInstance(args, process, port);
+ manager = managerConstructor.newInstance(args, process, ss);
// synchronization barrier
while (!reached) {
}).when(process).destroy();
// create class under test
- manager = managerConstructor.newInstance(args, process, port);
+ manager = managerConstructor.newInstance(args, process, ss);
// call stopTracing in separate thread
FutureTask<Boolean> stopTask = new FutureTask<>(new Callable<Boolean>() {
public void run() {
try {
Thread.sleep(TIME_EPS_MS);
- Socket socket = new Socket(InetAddress.getLocalHost(), port);
+ Socket socket = new Socket(InetAddress.getLocalHost(),
+ ss.getLocalPort());
ois = new ObjectInputStream(socket.getInputStream());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.flush();
package org.tizen.dynamicanalyzer.cli.tracing;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
private final static String application = "application";
private final static String applicationOpt = "-a";
private final static PrimitiveFeature cpu = PrimitiveFeature.CPU_USAGE;
+ // Command line option for CPU feature group
private final static String featureOptCPU = "-C=usage";
private final static PrimitiveFeature memory1 = PrimitiveFeature.SYSTEM_MEMORY;
private final static PrimitiveFeature memory2 = PrimitiveFeature.PROCESS_MEMORY;
+ // Command line option for Memory feature group
private final static String featureOptMEMORY = "-M";
private final static PrimitiveFeature file1 = PrimitiveFeature.DISK_IO;
private final static PrimitiveFeature file2 = PrimitiveFeature.FILE_ANALYSIS;
+ // Command line option for File feature group
private final static String featureOptFILE = "-F=all";
private final static PrimitiveFeature power = PrimitiveFeature.POWER_ESTIMATION;
+ // Command line option for Power estimation feature
private final static String featureOptPOWER = "-E";
private final static PrimitiveFeature screenshot = PrimitiveFeature.SCREENSHOT;
- private final static String featureOptSCREENSHOT = "-S";
+ // Command line option for screenshot periodically preference
+ private final static String prefOptScreenPer = "-S";
+ // Command line option for screenshot on scene transition preference
+ private final static String prefOptScreenOST = "-s";
private final static String period = "3";
private final static String output = "output.out";
private final static String outdefPrefix = File.separator+"test"+File.separator;
outputOpt,
outdefPrefix + output,
featureOptCPU,
- featureOptSCREENSHOT, period
+ prefOptScreenPer, period
// TODO duration option is not supported yet
// durationOpt, Long.toString(duration)
});
assertEquals(2, result.getFeatures().size());
assertTrue(result.getFeatures().contains(cpu));
assertTrue(result.getFeatures().contains(screenshot));
- assertTrue(result.isScreenshotPeriodSpecified());
+ assertFalse(result.getScreenshotOnSceneTransition());
assertEquals(Integer.parseInt(period), result.getScreenshotPeriod());
// TODO duration option is not supported yet
// assertEquals(duration, result.getDuration());
TracingArguments result = TracingArgumentsParser.parse(new String[] {
device,
applicationOpt, application,
- featureOptSCREENSHOT });
+ prefOptScreenOST });
assertNotNull(result);
assertTrue(result.isValid());
assertNull(result.getOutput());
assertEquals(0, result.getDuration());
- assertTrue(result.isScreenshotPeriodSpecified());
+ assertTrue(result.getScreenshotOnSceneTransition());
assertEquals(0, result.getScreenshotPeriod());
assertTrue(result.getFeatures().contains(PrimitiveFeature.SCREENSHOT));
}
+ @Test(expected = ParseException.class)
+ public void parse_screenshotsOnSceneTransitionWithArg() throws Exception {
+ TracingArguments result = TracingArgumentsParser.parse(new String[] {
+ device,
+ applicationOpt, application,
+ prefOptScreenOST, "3" });
+ assertNull(result);
+ }
+
@Test
public void parse_screenshotsPeriodically() throws Exception {
TracingArguments result = TracingArgumentsParser.parse(new String[] {
device,
applicationOpt, application,
- featureOptSCREENSHOT, period });
+ prefOptScreenPer, period });
assertNotNull(result);
assertTrue(result.isValid());
assertNull(result.getOutput());
assertEquals(0, result.getDuration());
- assertTrue(result.isScreenshotPeriodSpecified());
+ assertFalse(result.getScreenshotOnSceneTransition());
assertEquals(Integer.parseInt(period), result.getScreenshotPeriod());
assertTrue(result.getFeatures().contains(PrimitiveFeature.SCREENSHOT));
}
public void parse_screenshotsOnSceneTransition_featureBeforeApp() throws Exception {
TracingArguments result = TracingArgumentsParser.parse(new String[] {
device,
- featureOptSCREENSHOT,
+ prefOptScreenOST,
applicationOpt, application });
assertNotNull(result);
assertTrue(result.isValid());
assertNull(result.getOutput());
assertEquals(0, result.getDuration());
- assertTrue(result.isScreenshotPeriodSpecified());
+ assertTrue(result.getScreenshotOnSceneTransition());
assertEquals(0, result.getScreenshotPeriod());
assertTrue(result.getFeatures().contains(screenshot));
}
TracingArguments result = TracingArgumentsParser.parse(new String[] {
device,
applicationOpt, application,
- featureOptSCREENSHOT, "-"+period });
+ prefOptScreenPer,
+ "-" + period });
assertNull(result);
}
TracingArguments result = TracingArgumentsParser.parse(new String[] {
device,
applicationOpt, application,
- featureOptSCREENSHOT, "S" });
+ prefOptScreenPer,
+ "S" });
assertNull(result);
}
.setApplication(application)
.addFeature(cpu)
.setOutput(output)
- .setScreenshotPeriod(0);
+ .setScreenshotOnSceneTransition(true);
String[] result = TracingArgumentsParser.toStringArray(args);
assertNotNull(result);
assertEquals(8, result.length);
TracingArguments args = new TracingArguments()
.setDevice(device)
.setApplication(application)
- .setScreenshotPeriod(0);
+ .setScreenshotOnSceneTransition(true);
String[] result = TracingArgumentsParser.toStringArray(args);
assertNotNull(result);
assertEquals(4, result.length);
- assertEquals(featureOptSCREENSHOT, result[3]);
+ assertEquals(prefOptScreenOST, result[3]);
}
@Test
String[] result = TracingArgumentsParser.toStringArray(args);
assertNotNull(result);
assertEquals(5, result.length);
- assertEquals(featureOptSCREENSHOT, result[3]);
+ assertEquals(prefOptScreenPer, result[3]);
assertEquals(period, result[4]);
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import java.io.File;
-
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
.setScreenshotPeriod(0);
assertTrue(args.isValid());
}
+
+ @Test
+ public void isValid_withOkTransition() {
+ TracingArguments args = new TracingArguments().setDevice(device)
+ .setApplication(application).addFeature(feature)
+ .setScreenshotOnSceneTransition(true);
+ assertTrue(args.isValid());
+ }
+
}
*/
public class CommunicatorTest {
- final int PORT = 9000;
Message sentMessage = null;
@Before
*/
@Test
public void testSend() throws Exception {
- ServerSocket ss = new ServerSocket(PORT);
+ final ServerSocket ss = OppositeCommSide.getServerSocket();
Thread commThread = new Thread(new Runnable() {
@Override
public void run() {
try {
- Socket socket = new Socket(InetAddress.getLocalHost(), PORT);
+ Socket socket = new Socket(InetAddress.getLocalHost(),
+ ss.getLocalPort());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.flush();
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
*/
@Test
public void testSendByInternals() throws Exception {
- ServerSocket ss = new ServerSocket(PORT);
+ final ServerSocket ss = OppositeCommSide.getServerSocket();
Thread commThread = new Thread(new Runnable() {
@Override
public void run() {
try {
- Socket socket = new Socket(InetAddress.getLocalHost(), PORT);
+ Socket socket = new Socket(InetAddress.getLocalHost(),
+ ss.getLocalPort());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.flush();
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
*/
@Test
public void testSendByInternalsWithArgs() throws Exception {
- ServerSocket ss = new ServerSocket(PORT);
+ final ServerSocket ss = OppositeCommSide.getServerSocket();
Thread commThread = new Thread(new Runnable() {
@Override
public void run() {
try {
- Socket socket = new Socket(InetAddress.getLocalHost(), PORT);
+ Socket socket = new Socket(InetAddress.getLocalHost(),
+ ss.getLocalPort());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.flush();
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
*/
@Test
public void testGet() throws Exception {
- ServerSocket ss = new ServerSocket(PORT);
+ final ServerSocket ss = OppositeCommSide.getServerSocket();
Thread commThread = new Thread(new Runnable() {
@Override
public void run() {
try {
- Socket socket = new Socket(InetAddress.getLocalHost(), PORT);
+ Socket socket = new Socket(InetAddress.getLocalHost(),
+ ss.getLocalPort());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.flush();
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
*/
@Test
public void testGetWithArgs() throws Exception {
- ServerSocket ss = new ServerSocket(PORT);
+ final ServerSocket ss = OppositeCommSide.getServerSocket();
Thread commThread = new Thread(new Runnable() {
@Override
public void run() {
try {
- Socket socket = new Socket(InetAddress.getLocalHost(), PORT);
+ Socket socket = new Socket(InetAddress.getLocalHost(),
+ ss.getLocalPort());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.flush();
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
*/
public class ManagerCommunicationProcessorTest {
- static int PORT = 9000;
-
static ManagerCommunicationProcessor comProcessor;
static TracingProcessContext ctx;
@BeforeClass
public static void setUp() throws IOException {
Logger.init(InternalLogger.DEBUG);
- ServerSocket ss = new ServerSocket(PORT);
- opposite = new OppositeCommSide(PORT);
+ ServerSocket ss = OppositeCommSide.getServerSocket();
+ opposite = new OppositeCommSide(ss.getLocalPort());
Thread oppThread = new Thread(opposite);
oppThread.start();
Socket socket = ss.accept();
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
+import java.net.ServerSocket;
import java.net.Socket;
import org.junit.Ignore;
e.printStackTrace();
}
}
+
+ /**
+ * Method allocates available local socket.
+ *
+ * @return ServerSocket instance with free port.
+ */
+ public static ServerSocket getServerSocket() {
+ while (true) {
+ try {
+ ServerSocket ss = new ServerSocket(0);
+ return ss;
+ } catch (IOException e) {
+ }
+ }
+ }
}
\ No newline at end of file
static Thread comThread;
static OppositeCommSide opposite;
- static int PORT = 10000;
private static ProcessCommunicationProcessor comProcessor;
private static TracingProcess process;
private static Thread oppThread;
@BeforeClass
public static void setup() throws IOException {
Logger.init(InternalLogger.DEBUG);
- ServerSocket ss = new ServerSocket(PORT);
- opposite = new OppositeCommSide(PORT);
+ ServerSocket ss = OppositeCommSide.getServerSocket();
+ opposite = new OppositeCommSide(ss.getLocalPort());
oppThread = new Thread(opposite);
oppThread.start();
Socket socket = ss.accept();
feature = Feature.getFeature(ConfigureLabels.FEATURE_NAME_THREAD).getData();
assertEquals(Feature.THREAD_ANALYSIS.getIndex(), feature.getFeatureIndex());
- FeatureValueData featureValue = Whitebox.invokeMethod(setting, "getFeatureValueData",
- (Object) setting.getOptionsSelectedFeatureList(),
- (Object) Feature.getFeature(0));
- assertNull(featureValue);
-
// copyFeatureList()
List<FeatureValueData> source = new ArrayList<FeatureValueData>();
List<FeatureValueData> dest = new ArrayList<FeatureValueData>();
- Whitebox.invokeMethod(setting, "copyFeatureList", (Object) source, (Object) dest);
assertEquals(0, dest.size());
} catch (Exception e) {
Logger.exception(e);
}
@Test
- public void testProtocolOperation() {
- try {
- int level = setting.getSelectedOverheadLevel("mobile");
- assertEquals(1, level);
-
- long featureOverheadValue = Whitebox.invokeMethod(setting, "getFeatureOverheadValue",
- setting.getTarget("mobile"), Feature.OPENGL_ANALYSIS, false);
- assertEquals(800000, featureOverheadValue);
-
- double count = Whitebox.invokeMethod(setting, "calculateCallcount", (Object) null,
- (Object) Feature.FUNCTION_SAMPLING_RATE, true);
- assertEquals(3000, count, 0);
-
- count = Whitebox.invokeMethod(setting, "calculateCallcount", setting.getTarget(null),
- (Object) Feature.FUNCTION_SAMPLING_RATE, false);
- assertEquals(3000, count, 0);
- } catch (Exception e) {
- Logger.exception(e);
- }
- }
-
- @Test
public void testSettingOperation() {
TargetData target = setting.getTarget("not-wearable");
assertNull(target);
assertEquals(2, list.size());
assertTrue(list.contains("CPU Usage"));
assertTrue(list.contains("Core Usage"));
-
- // options tab feature
- assertTrue(setting.isOptionsSelectedFeature(Feature.RECORDING));
- assertFalse(setting.isOptionsSelectedFeature(Feature.SCREENSHOT_PERIODICALLY));
-
- setting.addOptionsSelectedFeature(Feature.SCREENSHOT_PERIODICALLY, 50);
- assertTrue(setting.isOptionsSelectedFeature(Feature.SCREENSHOT_PERIODICALLY));
-
- // selected value
- int featureValue = setting.getOptionsFeatureValue(Feature.SCREENSHOT_PERIODICALLY);
- assertEquals(50, featureValue);
-
- // init value
- featureValue = setting.getOptionsFeaturInitValue(Feature.RECORDING);
- assertEquals(0, featureValue);
-
- featureValue = setting.getOptionsFeaturInitValue(Feature.SCREENSHOT_PERIODICALLY);
- assertEquals(10, featureValue);
-
- // options selected feature chart list
- list = setting.getOptionsSelectedFeatureChartSet();
- assertEquals(1, list.size());
- assertTrue(list.contains("Screenshot"));
-
- setting.deleteOptionsSelectedFeature(Feature.SCREENSHOT_PERIODICALLY);
- assertFalse(setting.isOptionsSelectedFeature(Feature.SCREENSHOT_PERIODICALLY));
-
- // default value
- featureValue = setting.getOptionsFeatureValue(Feature.SCREENSHOT_PERIODICALLY);
- assertEquals(10, featureValue);
- }
-
- @Test
- public void testGetSelectedFeatures() {
- Set<Feature> selectedFeatures = setting.getSelectedFeatureSet();
- assertEquals(10, selectedFeatures.size());
- assertTrue(selectedFeatures.contains(Feature.SYSTEM));
- assertTrue(selectedFeatures.contains(Feature.SYSTEM_CPU));
- assertTrue(selectedFeatures.contains(Feature.SYSTEM_PROCESS));
- assertTrue(selectedFeatures.contains(Feature.SYSTEM_ALL_PROCESSES));
- assertTrue(selectedFeatures.contains(Feature.SYSTEM_SAMPLING_RATE));
- assertTrue(selectedFeatures.contains(Feature.FUNCTION_PROFILING));
- assertTrue(selectedFeatures.contains(Feature.FUNCTION_SAMPLING));
- assertTrue(selectedFeatures.contains(Feature.FUNCTION_SAMPLING_RATE));
- assertTrue(selectedFeatures.contains(Feature.RECORDING));
}
@Test
@AfterClass
public static void tesApplySettingData() {
// check initial FlatFeature set
- Set<FlatFeature> initFlatFeatureSet = Whitebox.getInternalState(targetData, "initFlatFeatureSet");
+ ArrayList<FlatFeature> initFlatFeatureSet = Whitebox.getInternalState(targetData, "initFlatFeatures");
targetData.addSelectedFlatFeature(FlatFeature.CPU_USAGE.getName());
targetData.applySettingData();
//check that settings applied
- Set<FlatFeature> newInitFlatFeatureSet = Whitebox.getInternalState(targetData, "initFlatFeatureSet");
+ ArrayList<FlatFeature> newInitFlatFeatureSet = Whitebox.getInternalState(targetData, "initFlatFeatures");
assertEquals(targetData.getSelectedFlatFeatures().size(), initFlatFeatureSet.size());
assertTrue(newInitFlatFeatureSet.containsAll(targetData.getSelectedFlatFeatures()));
}
@Test
public void testMakeAvailableFlatFeatureList() {
- Set<FlatFeature> availableFlatFeatureSet = targetData.getAvailableFlatFeatures();
+ List<FlatFeature> availableFlatFeatureSet = targetData
+ .getAvailableFlatFeatures();
assertEquals(FlatFeature.values().length,
availableFlatFeatureSet.size());
for (FlatFeature feature : FlatFeature.values()) {
@Test
public void testMakeSelectedFlatFeatureList() {
// check selectedFeatureList
- Set<FlatFeature> selectedFlatFeatures = targetData.getSelectedFlatFeatures();
+ List<FlatFeature> selectedFlatFeatures = targetData
+ .getSelectedFlatFeatures();
assertEquals(1, selectedFlatFeatures.size());
assertTrue(selectedFlatFeatures.contains(FlatFeature.SYSTEM_MEMORY));
// check initFeatureList
- Set<FlatFeature> initFlatFeatureSet = Whitebox.getInternalState(targetData, "initFlatFeatureSet");
+ ArrayList<FlatFeature> initFlatFeatureSet = Whitebox.getInternalState(targetData, "initFlatFeatures");
assertEquals(1, initFlatFeatureSet.size());
assertTrue(initFlatFeatureSet.contains(FlatFeature.SYSTEM_MEMORY));
Logger.error(e);
}
// check initial FlatFeature set
- Set<FlatFeature> initFlatFeatureSet = Whitebox.getInternalState(
- targetData, "initFlatFeatureSet");
+ ArrayList<FlatFeature> initFlatFeatureSet = Whitebox.getInternalState(
+ targetData, "initFlatFeatures");
assertEquals(1, initFlatFeatureSet.size());
assertTrue(initFlatFeatureSet.contains(FlatFeature.SYSTEM_MEMORY));
}
@Test
public void testRevertSettingData() {
// check initial FlatFeature set
- Set<FlatFeature> initFlatFeatureSet = Whitebox.getInternalState(
- targetData, "initFlatFeatureSet");
+ ArrayList<FlatFeature> initFlatFeatureSet = Whitebox.getInternalState(
+ targetData, "initFlatFeatures");
assertEquals(1, initFlatFeatureSet.size());
// change selected FlatFeatures
/* value for ID */
public static final int UNKNOWN_ID = -1; // ID resolving is valid, but cannot found
public static final int INVALID_ID = -2; // ID resolving is not valid
+ public static final int MAIN_EXECUTABLE_ID = -10;
/* save return values */
public static final int ERROR_EXTENSION_FAIL = -1;
SyncService service = device.getSyncService();
if (null != service) {
result = service.doPull(device.getFileEntry(remote), fileOut,
- NullSyncProgressMonitor.getInstance(), -1);
+ NullSyncProgressMonitor.getInstance(), 0);
service.close();
}
} catch (TimeoutException e) {
import org.tizen.dynamicanalyzer.util.Logger;
public abstract class DBTable implements IPreparedStatement, IResultSet {
+ /**
+ * Query to select all data from table.
+ */
+ protected static final String SELECT_ALL_QUERY = "select * from %s";
+
private List<DBColumn> columns = new ArrayList<DBColumn>();
protected DBInserter dbInserter = null;
}
}
+ /**
+ * Select all data from this table.
+ *
+ * @return list of rows where row is list of objects,
+ * <code>null</code> if there is no data in the table
+ */
+ public final List<List<Object>> selectAllObjectData() {
+ return SqlConnectionManager.executeQuery(String.format(SELECT_ALL_QUERY, getTableName()));
+ }
+
public final List<List<Object>> selectAllColumnData(String option) {
return selectData(null, option, this);
}
*/
private String getCurrentTargetName() {
String targetName = null;
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
if (target != null)
targetName = target.getTargetName();
return targetName;
@Override
public void setPageBySetting() {
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
final String targetName = target.getTargetName();
Display.getDefault().syncExec(new Runnable() {
final Set<String> selectedChartSet = new HashSet<String>();
// set selected chart list
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
Set<String> targetChartList = SettingDataManager.INSTANCE.getSelectedChartSet(target
.getTargetName());
selectedChartSet.addAll(targetChartList);
public static String UI_EVENT_LIST_NAME;
public static String UI_EVENT_LIST_TIME;
public static String UI_EVENT_LIST_DETAIL;
+ public static String APPSTARTUP_NOT_SUPPORTED_LABEL;
static {
// initialize resource bundle
NLS.initializeMessages(BUNDLE_NAME, TimelinePageLabels.class);
UI_EVENT_LIST_TYPE=Type
UI_EVENT_LIST_NAME=Name
UI_EVENT_LIST_TIME=Time
-UI_EVENT_LIST_DETAIL=Detail
\ No newline at end of file
+UI_EVENT_LIST_DETAIL=Detail
+
+APPSTARTUP_NOT_SUPPORTED_LABEL=Startup info cannot be collected when UI Hierarchy Analysis is selected.
\ No newline at end of file
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.protocol.DebugLog;
-import org.tizen.dynamicanalyzer.protocol.IProtocolConfig;
-import org.tizen.dynamicanalyzer.protocol.Protocol;
-import org.tizen.dynamicanalyzer.protocol.UnknownProtocolException;
import org.tizen.dynamicanalyzer.ui.page.BaseView;
import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.util.CommonUtil;
/** write information **/
// init selected information : for revert button
private String initTarget = null;
- private List<FeatureValueData> initOptionsSelectedFeatureList = new ArrayList<FeatureValueData>();
private List<FlatPreferences> initOptionsSelectedPreferenceList = new ArrayList<FlatPreferences>();
// mutable information
private String selectedTarget = null;
- private List<FeatureValueData> optionsSelectedFeatureList = new ArrayList<FeatureValueData>();
private List<FlatPreferences> optionsSelectedPreferenceList = new ArrayList<FlatPreferences>();
// available target list
totalOverheadRange.add(Long.parseLong(list[i]));
}
} else if (list[0].equals(SettingConstants.KEY_OPTIONS_SELECTED_FEATURE_LIST)) {
- for (int i = 1; i < list.length; i++) {
- String valueList[] = list[i].split(CommonConstants.COLON);
- FeatureValueData feature = new FeatureValueData(Feature.getFeature(Integer
- .parseInt(valueList[0])));
-
- if (valueList.length > 1) {
- feature.setValue(Integer.parseInt(valueList[1]));
- } // else : feature is on/off type
-
- optionsSelectedFeatureList.add(feature);
- }
-
- // init Feature list
- copyFeatureList(optionsSelectedFeatureList, initOptionsSelectedFeatureList);
+ // do nothing
} else if (list[0].equals(SettingConstants.KEY_SELECTED_PREFERENCES)) {
for (int i = 1; i < list.length; i++) {
String valueList[] = list[i].split(CommonConstants.COLON);
printWriter.println(writeDefaultFeatureList(SettingConstants.KEY_DEFAULT_FEATURE_LIST));
printWriter.println(writeCollection(totalOverheadRange,
SettingConstants.KEY_TOTAL_OVERHEAD_RANGE));
- printWriter.println(SettingConstants.KEY_OPTIONS_SELECTED_FEATURE_LIST
- + SettingConstants.WRITE_CSV_SEPARATOR + writeOptionsSelectedFeatureListData());
printWriter.println(SettingConstants.KEY_SELECTED_PREFERENCES
+ SettingConstants.WRITE_CSV_SEPARATOR + writeOptionsSelectedPreferencesListData());
return buffer.toString();
}
- private String writeOptionsSelectedFeatureListData() {
- StringBuffer buffer = new StringBuffer();
- for (int i = 0; i < optionsSelectedFeatureList.size(); i++) {
- FeatureValueData feature = optionsSelectedFeatureList.get(i);
- buffer.append(feature.getKey().getIndex());
- if (feature.getValue() >= 0) { // detail feature
- buffer.append(String.valueOf(CommonConstants.COLON + feature.getValue()));
- } // else : (main feature or sub feature) feature does not have a value.
-
- if (i < optionsSelectedFeatureList.size() - 1) {
- buffer.append(SettingConstants.WRITE_CSV_SEPARATOR);
- } // else : the last value will be written to a csv file does not contain a comma.
- }
- return buffer.toString();
- }
-
private String writeOptionsSelectedPreferencesListData() {
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < optionsSelectedPreferenceList.size(); i++) {
}
/****************************** protocol operation ******************************/
+ @Deprecated
public int getSelectedOverheadLevel(String targetName) {
- int totalRange = 0;
- long calculateValue = 0;
-
- // get target information
- TargetData target = getTarget(targetName);
- if (null != target) {
- // option page overhead
- for (int i = 0; i < optionsSelectedFeatureList.size(); i++) {
- calculateValue += getFeatureOverheadValue(target, optionsSelectedFeatureList.get(i)
- .getKey(), true);
- }
-
- // get selected feature
- List<FeatureValueData> featureList = target.getSelectedFeatureList();
- for (int i = 0; i < featureList.size(); i++) {
- calculateValue += getFeatureOverheadValue(target, featureList.get(i).getKey(),
- false);
- }
- }
-
- // check total overhead range
- for (int i = 0; i < totalOverheadRange.size(); i++) {
- if (calculateValue <= totalOverheadRange.get(i)) {
- return i + 1;
- }
-
- if ((i == totalOverheadRange.size() - 1)
- && (totalOverheadRange.get(i) < calculateValue)) {
- return totalOverheadRange.size() + 1;
- }
- }
-
- return totalRange;
- }
-
- private long getFeatureOverheadValue(TargetData target, Feature feature, boolean isOption) {
- long calculateValue = 0;
-
- // get feature information
- IProtocolConfig[] pconfigs = null;
- try {
- pconfigs = Protocol.getProtocolConfig(target.getProtocolVersion(), feature);
- } catch (UnknownProtocolException e) {
- Logger.warning(e.getMessage());
- }
-
- if (pconfigs != null) {
- for (int i = 0; i < pconfigs.length; i++) {
- long overhead = (long) pconfigs[i].getOverhead();
- int callcount = pconfigs[i].getCallcount();
- if (callcount > 0) {
- calculateValue += (overhead * callcount);
- } else if (pconfigs[i].getFeatureForFrequency() != null) {
- Feature featureForFrequency = pconfigs[i].getFeatureForFrequency();
- calculateValue += (overhead * calculateCallcount(target, featureForFrequency,
- isOption));
- } // else : do nothing
- }
- }
-
- return calculateValue;
- }
-
- private double calculateCallcount(TargetData target, Feature featureForFrequency,
- boolean isOption) {
- // get input value
- int inputValue = 0;
- double count = 0;
-
- if (isOption) { // options feature
- inputValue = getOptionsFeatureValue(featureForFrequency);
- } else {
- inputValue = target.getSelectedFeatureValue(featureForFrequency);
- if (inputValue < 0) {
- inputValue = featureForFrequency.getData().getDefaultValue();
- }
- }
-
- // calculate
- if (featureForFrequency == Feature.SYSTEM_SAMPLING_RATE
- || featureForFrequency == Feature.FUNCTION_SAMPLING_RATE) {
- count = 1000.0 / inputValue; // millisecond
- } else if (featureForFrequency == Feature.SCREENSHOT_PERIODICALLY) {
- count = 1.0 / inputValue; // second
- }
-
- return count * SettingConstants.OVERHEAD_AVG_SECONDS;
+ return 0;
}
/********************************** chart set manipulation ***************************/
+
+ @Deprecated
public Set<String> getOptionsSelectedFeatureChartSet() {
- Set<String> selectedChartSet = new HashSet<String>();
- for (int i = 0; i < optionsSelectedFeatureList.size(); i++) {
- FeatureData feature = optionsSelectedFeatureList.get(i).getKey().getData();
- if (feature.getChartList().size() > 0) {
- selectedChartSet.addAll(feature.getChartList());
- }
- }
- return selectedChartSet;
+ return new HashSet<String>();
}
-
/**
* Get chart information shown on the screen.
*
TargetData target = getTarget(targetName);
if (null != target) {
Set<String> selectedChartSet = new HashSet<String>();
- Set<FlatFeature> featureSet = target.getSelectedFlatFeatures();
+ List<FlatFeature> featureSet = target.getSelectedFlatFeatures();
for (FlatFeature feature : featureSet) {
if (feature.getChart() != null)
selectedChartSet.add(feature.getChart());
*
* @return device description as an instance of {@link TargetData} or null
*/
- public TargetData getConnected() {
+ public TargetData getConnectedTargetOrNull() {
DeviceInfo currentDevice = Global.getCurrentDeviceInfo();
* equals to selected target.
*/
public boolean checkConnectedTargetType() {
- TargetData connected = getConnected();
+ TargetData connected = getConnectedTargetOrNull();
if (connected == null) // User should be able to select any target if no
// device connected.
return true;
*
* @return device description as an instance of {@link TargetData} or null
*/
- public TargetData getConnectedTarget() {
- TargetData tData = getConnected();
+ public TargetData getConnectedTargetOrSelected() {
+ TargetData tData = getConnectedTargetOrNull();
if (tData != null)
return tData;
}
/********************************** Feature manipulation ******************************/
+ @Deprecated
public List<Feature> getDefaultFeatureList() {
return Collections.unmodifiableList(defaultFeatureList);
}
+ @Deprecated
public List<FeatureValueData> getOptionsSelectedFeatureList() {
- return Collections.unmodifiableList(optionsSelectedFeatureList);
+ return new ArrayList<FeatureValueData>();
}
public List<FlatPreferences> getOptionsSelectedPreferencesList() {
return Collections.unmodifiableList(optionsSelectedPreferenceList);
}
+ @Deprecated
public void addOptionsSelectedFeature(Feature feature, int featureValue) {
- FeatureValueData featureData = getFeatureValueData(optionsSelectedFeatureList, feature);
- // create FeatureValueData
- if (featureData == null) {
- featureData = new FeatureValueData(feature);
- optionsSelectedFeatureList.add(featureData);
- } // else : set value
-
- featureData.setValue(featureValue);
}
public void addOptionsSelectedPreference(FlatPreferences feature, int featureValue) {
}
}
+ @Deprecated
public void deleteOptionsSelectedFeature(Feature feature) {
- for (int i = 0; i < optionsSelectedFeatureList.size(); i++) {
- if (optionsSelectedFeatureList.get(i).getKey() == feature) {
- optionsSelectedFeatureList.remove(i);
- break;
- } // else : do nothing
- }
}
public void deleteOptionsSelectedPreference(FlatPreferences feature) {
}
}
+ @Deprecated
public boolean isOptionsSelectedFeature(Feature feature) {
- FeatureValueData featureVal = getFeatureValueData(optionsSelectedFeatureList, feature);
- if (featureVal != null) {
- return true;
- } else {
- return false;
- }
+ return false;
}
public boolean isOptionsSelectedPrefereces(FlatPreferences feature) {
return getSelectedFlatFeatureSet().contains(feature);
}
+ @Deprecated
public int getOptionsFeatureValue(Feature feature) {
- int value = 0;
- FeatureValueData featureVal = getFeatureValueData(optionsSelectedFeatureList, feature);
-
- // check selected feature
- if (featureVal != null) {
- value = featureVal.getValue();
- } else {
- // get default value
- value = feature.getData().getDefaultValue();
- }
-
- return value;
+ return -1;
}
public int getOptionsPreferencesValue(FlatPreferences feature) {
return value;
}
+ @Deprecated
public int getOptionsFeaturInitValue(Feature feature) {
- // get init value
- int value = -1;
- for (int i = 0; i < initOptionsSelectedFeatureList.size(); i++) {
- if (initOptionsSelectedFeatureList.get(i).getKey() == feature) {
- value = initOptionsSelectedFeatureList.get(i).getValue();
- break;
- }
- }
-
- // get default value
- if (value == -1) {
- value = feature.getData().getDefaultValue();
- }
- return value;
+ return -1;
}
- private FeatureValueData getFeatureValueData(List<FeatureValueData> featureList, Feature feature) {
- // null check
- if ((featureList == null) || (feature == null)) {
- return null;
- } // else : search FeatureValueData object
-
- for (int i = 0; i < featureList.size(); i++) {
- if (featureList.get(i).getKey() == feature) {
- return featureList.get(i);
- } // else : do nothing
- }
- return null;
- }
-
private int getFlatPreferences(List<FlatPreferences> featureList, FlatPreferences feature) {
if ((featureList == null) || (feature == null)) {
return -1;
TargetData target = getTarget(targetName);
if (null != target) {
- Set<FlatFeature> featureSet = target.getSelectedFlatFeatures();
- for (FlatFeature feature : featureSet) {
+ List<FlatFeature> features = target.getSelectedFlatFeatures();
+ for (FlatFeature feature : features) {
if (feature.getPage() != null)
selectedPageList.add(feature.getPage());
}
}
/******************************* miscellaneous **********************************/
- private void copyFeatureList(List<FeatureValueData> source, List<FeatureValueData> dest) {
- dest.clear();
-
- if (source.isEmpty()) {
- return;
- }
-
- for (int i = 0; i < source.size(); i++) {
- dest.add(new FeatureValueData(source.get(i)));
- }
- }
-
public boolean changedFeatures() {
// check target
if (initTarget.equals(selectedTarget) == false) {
}
for (int i = 0; i < optionsSelectedPreferenceList.size(); i++) {
- // check featureName
+ // check preferenceName
FlatPreferences preference = optionsSelectedPreferenceList.get(i);
int initPreferenceIndex = getFlatPreferences(initOptionsSelectedPreferenceList, preference);
if (initPreferenceIndex < 0) {
writeSettingFile();
}
+ @Deprecated
public Set<Feature> getSelectedFeatureSet() {
- Set<Feature> selectedFeatures = new HashSet<Feature>();
-
- // add default features
- selectedFeatures.addAll(defaultFeatureList);
-
- // add selected target features
- TargetData target = getConnectedTarget();
- List<FeatureValueData> featureList = target.getSelectedFeatureList();
- for (int i = 0; i < featureList.size(); i++) {
- selectedFeatures.add(featureList.get(i).getKey());
- }
-
- // add option features
- for (int i = 0; i < optionsSelectedFeatureList.size(); i++) {
- selectedFeatures.add(optionsSelectedFeatureList.get(i).getKey());
- }
-
- return selectedFeatures;
+ return new HashSet<Feature>();
}
public Set<FlatPreferences> getSelectedPreferenceSet() {
- Set<FlatFeature> featureSet = getConnectedTarget()
+ List<FlatFeature> featureSet = getConnectedTargetOrSelected()
.getSelectedFlatFeatures();
Set<FlatPreferences> selectedFeatures = new HashSet<FlatPreferences>();
return selectedFeatures;
}
- // TODO: Function related with <FlatFeature> will replace <Feature> functions
+ /**
+ * Returns selected FlatFeatures for selected target.
+ *
+ * @return unmodified set of selected FlatFeatures ordered by selection
+ * order
+ */
public Set<FlatFeature> getSelectedFlatFeatureSet() {
- Set<FlatFeature> selectedFlatFeatures = new HashSet<FlatFeature>();
-
- // add selected target features
- TargetData target = getConnectedTarget();
- Set<FlatFeature> featureSet = target.getSelectedFlatFeatures();
- selectedFlatFeatures.addAll(featureSet);
- Logger.debug(selectedFlatFeatures);
-
- return selectedFlatFeatures;
+ TargetData target = getTarget(null);
+ Set<FlatFeature> buf = new HashSet<FlatFeature>();
+ buf.addAll(target.getSelectedFlatFeatures());
+ return buf;
}
public boolean isPlatformDA() {
}
// TODO : another function is implemented, will be deleted.
+ @Deprecated
public String getPlatform() {
// if (null == platform || platform.isEmpty() ||
// platform.equals(ConfigureLabels.PLATFORM_ETC)) {
* @param enable whether Screenshot feature should be enabled
*/
public void enableScreenshotFeature(boolean enable) {
- TargetData target = getConnectedTarget();
+ TargetData target = getConnectedTargetOrSelected();
Set<String> targetChartList = getSelectedChartSet(target.getTargetName());
if (!targetChartList.contains(TimelineChartLabels.SCREENSHOT_CHART_TITLE)) {
BaseView baseView = (BaseView) WorkbenchUtil.getViewPart(BaseView.ID);
if (enable)
target.addSelectedFlatFeature(FlatFeature.SCREENSHOT.getName());
else
- target.removeSelectedFeature(FlatFeature.SCREENSHOT.getName());
+ target.removeSelectedFlatFeature(FlatFeature.SCREENSHOT.getName());
}
}
}
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.protocol.Protocol;
-import org.tizen.dynamicanalyzer.util.Logger;
public class TargetData {
/** read information **/
private Protocol protocolVersion = Protocol.VERSION_UNKNOWN;
// available information
- private List<Template> availableTemplateList = new ArrayList<Template>();
- private List<Feature> availableFeatureList = new ArrayList<Feature>();
- private Set<FlatFeature> availableFlatFeatureSet = new HashSet<FlatFeature>();
+ private List<FlatFeature> availableFlatFeatures = new ArrayList<FlatFeature>();
/** write information **/
// init selected information : for revert button
- private Template initTemplate = null;
- private List<FeatureValueData> initFeatureList = new ArrayList<FeatureValueData>();
- private Set<FlatFeature> initFlatFeatureSet = new HashSet<FlatFeature>();
+ private List<FlatFeature> initFlatFeatures = new ArrayList<FlatFeature>();
// dialog selected information
- private Template selectedTemplate = null;
- private List<FeatureValueData> selectedFeatureList = new ArrayList<FeatureValueData>();
- private Set<FlatFeature> selectedFlatFeatureSet = new HashSet<FlatFeature>();
+ private List<FlatFeature> selectedFlatFeatures = new ArrayList<FlatFeature>();
private List<String> availableChartList = new ArrayList<String>();
public TargetData(String targetName) {
this.availableChartList.addAll(availableChartList);
}
+ @Deprecated
public Template getSelectedTemplate() {
- return selectedTemplate;
+ return null;
}
+ @Deprecated
public void setSelectedTemplate(Template template) {
- if (this.initTemplate == null) {
- this.initTemplate = template;
- }
- this.selectedTemplate = template;
}
+ @Deprecated
public List<Template> getAvailableTemplateList() {
- return Collections.unmodifiableList(availableTemplateList);
+ return new ArrayList<Template>();
}
+ @Deprecated
public List<Feature> getAvailableFeatureList() {
- return Collections.unmodifiableList(availableFeatureList);
+ return new ArrayList<Feature>();
}
- public Set<FlatFeature> getAvailableFlatFeatures() {
- return Collections.unmodifiableSet(availableFlatFeatureSet);
+ public List<FlatFeature> getAvailableFlatFeatures() {
+ return Collections.unmodifiableList(availableFlatFeatures);
}
public List<String> getAvailableChartList() {
return Collections.unmodifiableList(availableChartList);
}
- public void setSelectedFeatureList(List<FeatureValueData> selectedFeatureList) {
- this.selectedFeatureList.clear();
- this.selectedFeatureList.addAll(selectedFeatureList);
+ @Deprecated
+ public void setSelectedFeatureList(
+ List<FeatureValueData> selectedFeatureList) {
}
public void setSelectedFlatFeatures(Set<FlatFeature> set) {
- this.selectedFlatFeatureSet.clear();
- this.selectedFlatFeatureSet.addAll(set);
+ this.selectedFlatFeatures.clear();
+ this.selectedFlatFeatures.addAll(set);
}
+ @Deprecated
public void addSelectedFeature(String featureName) {
- FeatureValueData featureValue = new FeatureValueData(Feature.getFeature(featureName));
- this.selectedFeatureList.add(featureValue);
}
public void addSelectedFlatFeature(String featureName) {
FlatFeature feature = FlatFeature.getFlatFeature(featureName);
if (null != feature) {
- if (!this.selectedFlatFeatureSet.contains(feature)) {
- this.selectedFlatFeatureSet.add(feature);
+ if (!this.selectedFlatFeatures.contains(feature)) {
+ this.selectedFlatFeatures.add(feature);
}
if (feature == FlatFeature.SCREENSHOT)
SettingDataManager.INSTANCE.addOptionsSelectedPreference(FlatPreferences.SCREENSHOT_ON_SCENE_TRANSITION, 1);
}
}
+ @Deprecated
public void removeSelectedFeature(String featureName) {
-
}
public void removeSelectedFlatFeature(String featureName) {
FlatFeature feature = FlatFeature.getFlatFeature(featureName);
- selectedFlatFeatureSet.remove(feature);
+ selectedFlatFeatures.remove(feature);
}
+ @Deprecated
public void clearSelectedFeature() {
- this.selectedFeatureList.clear();
}
+ @Deprecated
public List<FeatureValueData> getSelectedFeatureList() {
- return Collections.unmodifiableList(selectedFeatureList);
+ return new ArrayList<FeatureValueData>();
}
- public Set<FlatFeature> getSelectedFlatFeatures() {
- return Collections.unmodifiableSet(selectedFlatFeatureSet);
+ public List<FlatFeature> getSelectedFlatFeatures() {
+ return Collections.unmodifiableList(selectedFlatFeatures);
}
+ @Deprecated
public boolean isSelectedFeature(Feature feature) {
- FeatureValueData featureValue = getFeatureValueData(selectedFeatureList, feature);
- if (featureValue != null) {
- return true;
- } else {
- return false;
- }
+ return false;
}
public boolean isSelectedFlatFeature(String name) {
FlatFeature feature = FlatFeature.getFlatFeature(name);
- return selectedFlatFeatureSet.contains(feature);
- }
-
- private FeatureValueData getFeatureValueData(List<FeatureValueData> featureList, Feature feature) {
- // null check
- if ((featureList == null) || (feature == null)) {
- return null;
- } // else : search FeatureValueData object
-
- for (int i = 0; i < featureList.size(); i++) {
- if (featureList.get(i).getKey() == feature) {
- return featureList.get(i);
- } // else : do nothing
- }
- return null;
+ return selectedFlatFeatures.contains(feature);
}
/**
*
* @param template selected template
*/
+ @Deprecated
public void changeSelectedFeatureList(Template template) {
- if (template == selectedTemplate) {
- selectedFeatureList.clear();
- selectedFeatureList.addAll(template.getData().getFeatureList());
- } else {
- Logger.debug("The template is not selected.");
- }
}
/**
* @param feature one of the selected features
* @return featureValue (If the feature is not selected, returns -1.)
*/
+ @Deprecated
public int getSelectedFeatureValue(Feature feature) {
- FeatureValueData featureValue = getFeatureValueData(selectedFeatureList, feature);
- if (featureValue == null) {
- return -1;
- } else {
- return featureValue.getValue();
- }
+ return -1;
}
public void makeDetailInformation(String list[]) {
// written unit test for each of the sub method
if (list[1].equals(SettingConstants.KEY_PROTOCOL_VERSION)) {
protocolVersion = Protocol.getVersion(list[2]);
- } else if (list[1].equals(SettingConstants.KEY_AVAILABLE_TEMPLATE_LIST)) {
- makeAvailableTemplateList(list);
- } else if (list[1].equals(SettingConstants.KEY_SELECTED_TEMPLATE)) {
- if ((list[2] != null) && (list[2].isEmpty() == false)) {
- setSelectedTemplate(Template.getTemplate(Integer.parseInt(list[2])));
- }
- } else if (list[1].equals(SettingConstants.KEY_AVAILABLE_FEATURE_LIST)) {
- makeAvailableFeatureList(list);
} else if (list[1].equals(SettingConstants.KEY_AVAILABLE_FLATFEATURE_LIST)) {
makeAvailableFlatFeatureList(list);
- } else if (list[1].equals(SettingConstants.KEY_SELECTED_FEATURE_LIST)) {
- makeSelectedFeatureList(list);
} else if (list[1].equals(SettingConstants.KEY_SELECTED_FLATFEATURE_LIST)) {
makeSelectedFlatFeatureList(list);
} else if (list[1].equals(SettingConstants.KEY_AVAILABLE_CHART_LIST)) {
}
}
- private void makeAvailableTemplateList(String list[]) {
- if (list != null) {
- for (int i = 2; i < list.length; i++) {
- availableTemplateList.add(Template.getTemplate(Integer.parseInt(list[i])));
- }
- } // else do nothing
- }
-
- private void makeAvailableFeatureList(String list[]) {
- if (list != null) {
- for (int i = 2; i < list.length; i++) {
- availableFeatureList.add(Feature.getFeature(Integer.parseInt(list[i])));
- }
- } // else do nothing
- }
-
private void makeAvailableFlatFeatureList(String list[]) {
- availableFlatFeatureSet.clear();
+ availableFlatFeatures.clear();
if (list != null) {
for (int i = 2; i < list.length; i++) {
- availableFlatFeatureSet.add(FlatFeature.getFlatFeature(Integer.parseInt(list[i])));
+ availableFlatFeatures.add(FlatFeature.getFlatFeature(Integer
+ .parseInt(list[i])));
}
} // else do nothing
}
- private void makeSelectedFeatureList(String list[]) {
- for (int i = 2; i < list.length; i++) {
- String valueList[] = list[i].split(CommonConstants.COLON);
- FeatureValueData feature = new FeatureValueData(Feature.getFeature(Integer
- .parseInt(valueList[0])));
-
- if (valueList.length > 1) {
- feature.setValue(Integer.parseInt(valueList[1]));
- } // else : feature is check status
-
- selectedFeatureList.add(feature);
- }
- // init Feature list
- copyFeatureList(selectedFeatureList, initFeatureList);
- }
private void makeSelectedFlatFeatureList(String list[]) {
- selectedFlatFeatureSet.clear();
+ selectedFlatFeatures.clear();
for (int i = 2; i < list.length; i++) {
String valueList[] = list[i].split(CommonConstants.COLON);
FlatFeature feature = FlatFeature.getFlatFeature(Integer.parseInt(valueList[0]));
- selectedFlatFeatureSet.add(feature);
+ selectedFlatFeatures.add(feature);
}
// init FlatFeature list
- copyFlatFeatureSet(selectedFlatFeatureSet, initFlatFeatureSet);
+ copyFlatFeatures(selectedFlatFeatures, initFlatFeatures);
}
private void makeAvailableChartList(String list[]) {
+ SettingConstants.KEY_PROTOCOL_VERSION + SettingConstants.WRITE_CSV_SEPARATOR
+ protocolVersion);
writer.println(targetName + SettingConstants.WRITE_CSV_SEPARATOR
- + SettingConstants.KEY_AVAILABLE_TEMPLATE_LIST
- + SettingConstants.WRITE_CSV_SEPARATOR + writeAvailableTemplateListData());
- writer.println(targetName + SettingConstants.WRITE_CSV_SEPARATOR
- + SettingConstants.KEY_SELECTED_TEMPLATE + SettingConstants.WRITE_CSV_SEPARATOR
- + selectedTemplate.getIndex());
- writer.println(targetName + SettingConstants.WRITE_CSV_SEPARATOR
- + SettingConstants.KEY_AVAILABLE_FEATURE_LIST
- + SettingConstants.WRITE_CSV_SEPARATOR + writeAvailableFeatureListData());
- writer.println(targetName + SettingConstants.WRITE_CSV_SEPARATOR
+ SettingConstants.KEY_AVAILABLE_FLATFEATURE_LIST
+ SettingConstants.WRITE_CSV_SEPARATOR + writeAvailableFlatFeaturesData());
writer.println(targetName + SettingConstants.WRITE_CSV_SEPARATOR
- + SettingConstants.KEY_SELECTED_FEATURE_LIST + SettingConstants.WRITE_CSV_SEPARATOR
- + writeSelectedFeatureListData());
- writer.println(targetName + SettingConstants.WRITE_CSV_SEPARATOR
+ SettingConstants.KEY_SELECTED_FLATFEATURE_LIST + SettingConstants.WRITE_CSV_SEPARATOR
+ writeSelectedFlatFeaturesData());
writer.println(targetName + SettingConstants.WRITE_CSV_SEPARATOR
writer.checkError();
}
- private String writeSelectedFeatureListData() {
- StringBuffer buffer = new StringBuffer();
- for (int i = 0; i < selectedFeatureList.size(); i++) {
- FeatureValueData feature = selectedFeatureList.get(i);
-
- buffer.append(feature.getKey().getIndex());
- if (feature.getValue() > 0) { // detail feature
- buffer.append(String.valueOf(CommonConstants.COLON + feature.getValue()));
- } // else : (main feature or sub feature) feature does not have a value.
-
- if (i < selectedFeatureList.size() - 1) {
- buffer.append(SettingConstants.WRITE_CSV_SEPARATOR);
- } // else : the last value will be written to a csv file does not contain a comma.
- }
- return buffer.toString();
- }
-
private String writeSelectedFlatFeaturesData() {
StringBuffer buffer = new StringBuffer();
- Iterator<FlatFeature> iter = selectedFlatFeatureSet.iterator();
+ Iterator<FlatFeature> iter = selectedFlatFeatures.iterator();
while (iter.hasNext()) {
FlatFeature feature = iter.next();
return buffer.toString();
}
- private String writeAvailableTemplateListData() {
- StringBuffer buffer = new StringBuffer();
- for (int i = 0; i < availableTemplateList.size(); i++) {
- if (i < availableTemplateList.size() - 1) {
- buffer.append(availableTemplateList.get(i).getIndex()
- + SettingConstants.WRITE_CSV_SEPARATOR);
- } else {
- buffer.append(availableTemplateList.get(i).getIndex());
- }
- }
- return buffer.toString();
- }
-
- private String writeAvailableFeatureListData() {
- StringBuffer buffer = new StringBuffer();
- for (int i = 0; i < availableFeatureList.size(); i++) {
- if (i < availableFeatureList.size() - 1) {
- buffer.append(availableFeatureList.get(i).getIndex()
- + SettingConstants.WRITE_CSV_SEPARATOR);
- } else {
- buffer.append(availableFeatureList.get(i).getIndex());
- }
- }
- return buffer.toString();
- }
-
private String writeAvailableFlatFeaturesData() {
StringBuffer buffer = new StringBuffer();
- Iterator<FlatFeature> iter = availableFlatFeatureSet.iterator();
+ Iterator<FlatFeature> iter = availableFlatFeatures.iterator();
while (iter.hasNext()) {
FlatFeature feature = iter.next();
if (iter.hasNext()) {
public boolean changedFlatFeatures() {
// check FlatFeature
- if (selectedFlatFeatureSet.size() != initFlatFeatureSet.size()) {
+ if (selectedFlatFeatures.size() != initFlatFeatures.size()) {
return true;
}
- if (selectedFlatFeatureSet.containsAll(initFlatFeatureSet)) {
+ if (selectedFlatFeatures.containsAll(initFlatFeatures)) {
return false;
}
return true;
public void applySettingData() {
// set feature
- copyFlatFeatureSet(selectedFlatFeatureSet, initFlatFeatureSet);
+ copyFlatFeatures(selectedFlatFeatures, initFlatFeatures);
}
public void revertSettingData() {
// set feature
- copyFlatFeatureSet(initFlatFeatureSet, selectedFlatFeatureSet);
- }
-
- private void copyFeatureList(List<FeatureValueData> source, List<FeatureValueData> dest) {
- dest.clear();
-
- if (source.isEmpty()) {
- return;
- }
-
- for (int i = 0; i < source.size(); i++) {
- dest.add(new FeatureValueData(source.get(i)));
- }
+ copyFlatFeatures(initFlatFeatures, selectedFlatFeatures);
}
- private void copyFlatFeatureSet(Set<FlatFeature> source,
- Set<FlatFeature> dest) {
+ private void copyFlatFeatures(List<FlatFeature> source,
+ List<FlatFeature> dest) {
dest.clear();
if (source.isEmpty()) {
private void resizePageButton() {
int width = WorkbenchUtil.getWorkbenchWindow().getShell().getBounds().width;
- int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTarget().getTargetName()).size();
+ int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTargetOrSelected().getTargetName()).size();
int newWidth = (width/pageCount > DATabComposite.LONG_TAB_WIDTH) ? DATabComposite.LONG_TAB_WIDTH : width/pageCount;
((BaseView)WorkbenchUtil.getViewPart(BaseView.ID)).getMainTab().updateTabButtonsWidth(newWidth);
*/
// check if the inside call is set or not
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
if (target.isSelectedFeature(Feature.INTERNAL_PROBE_FILE)) {
isInculdeInsideCall = true;
}
package org.tizen.dynamicanalyzer.ui.info.appStartup;
+import java.util.Arrays;
+
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Label;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
+import org.tizen.dynamicanalyzer.nl.TimelinePageLabels;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.resources.FontResources;
+import org.tizen.dynamicanalyzer.setting.FlatFeature;
+import org.tizen.dynamicanalyzer.setting.SettingConstants;
+import org.tizen.dynamicanalyzer.setting.SettingDataManager;
import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewComposite;
private AppStartupTable nativeTable = null;
private WebAppStartupTable webTable = null;
+ /**
+ * Stub to display when data is not collected.
+ */
+ private Label startUpNotSupportedLabel;
+
public AppStartupView(Composite parent, int style) {
super(parent, style, false);
this.setLayout(new FillLayout());
setTitle(InformationViewLabels.APP_STARTUP_VIEW_TITLE);
contents = getContentArea();
- contents.setBackground(ColorResources.WINDOW_BG_COLOR);
+ contents.setBackground(ColorResources.TABLE_HEADER_BG);
stackLayout = new StackLayout();
contents.setLayout(stackLayout);
webTable = new WebAppStartupTable(contents, SWT.NONE, SWT.MULTI
| SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
- // select native or web table
- Project currentProject = Global.getProject();
- if (currentProject == null) {
- stackLayout.topControl = nativeTable;
- } else {
- changeTable(currentProject.isWebApplication());
+ // create stub label
+ startUpNotSupportedLabel = new Label(contents,
+ SWT.NONE | SWT.WRAP | SWT.BORDER);
+ startUpNotSupportedLabel
+ .setText(TimelinePageLabels.APPSTARTUP_NOT_SUPPORTED_LABEL);
+ startUpNotSupportedLabel.setFont(FontResources.TABLE_HEADER_FONT);
+ startUpNotSupportedLabel.setAlignment(SWT.CENTER);
+
+ if (!hideIfNotSupported()) {
+ // select native or web table
+ Project currentProject = Global.getProject();
+ if (currentProject == null) {
+ stackLayout.topControl = nativeTable;
+ } else {
+ changeTable(currentProject.isWebApplication());
+ }
+ // set data manager
+ DataManagerRegistry.registerPageDataManager(AppStartupDataManager.getInstance());
}
-
- // set data manager
- DataManagerRegistry.registerPageDataManager(AppStartupDataManager.getInstance());
}
public void setObservingViews(String[] viewIDs) {
// select native or web table
public void changeTable(boolean isWeb) {
+ if (hideIfNotSupported())
+ return;
if (isWeb) {
stackLayout.topControl = webTable;
} else {
@Override
public void updateView() {
- ((DATableComposite)stackLayout.topControl).updateTable();
+ if (hideIfNotSupported())
+ return;
+ if (stackLayout.topControl instanceof DATableComposite) {
+ ((DATableComposite)stackLayout.topControl).updateTable();
+ }
}
@Override
public void updateView(DAViewData data) {
+ if (hideIfNotSupported())
+ return;
// other view selection occurred
- ((DATableComposite)stackLayout.topControl).deselectAll();
-
+ if (stackLayout.topControl instanceof DATableComposite)
+ ((DATableComposite) stackLayout.topControl).deselectAll();
if (data instanceof DASelectionData) {
DASelectionData selData = (DASelectionData) data;
long start = selData.getStartTime();
- long end = selData.getEndTime();
+ long end = selData.getEndTime();
// set selections item
if (stackLayout.topControl == nativeTable) {
updateView();
}
}
+
+ private boolean hideIfNotSupported() {
+ boolean hide = false;
+ // Check recently created/opened project
+ Project curProject = Global.getProject();
+ if (null != curProject && null != curProject.getPageTabList())
+ hide = Arrays.asList(curProject.getPageTabList())
+ .contains(SettingConstants.PAGE_NAME_HIERARCHY);
+ // If no project set yet - check current tracing settings
+ else
+ hide = SettingDataManager.INSTANCE.getSelectedFlatFeatureSet()
+ .contains(FlatFeature.UI_HIERARCHY_ANALYSIS);
+ stackLayout.topControl = hide ? startUpNotSupportedLabel : stackLayout.topControl;
+ return hide;
+ }
@Override
public void clear() {
nativeTable.clear();
webTable.clear();
+ hideIfNotSupported();
}
@Override
callStackDataTable.insertData(insertData);
// remove unnecessary callstackdata from memory
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
if (target.isSelectedFeature(Feature.FUNCTION_SAMPLING)) {
// sample feature is on
long lastSampleSeq = FunctionUsageProfiler.getInstance().getLastSampleSeq();
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Listener;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
public InteractiveTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
- table.addListener(SWT.Expand, new Listener() {
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, true);
- }
- });
- table.addListener(SWT.Collapse, new Listener() {
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, false);
- }
- });
-
table.addSelectionListener(new SelectionListener() {
@Override
public void widgetSelected(SelectionEvent e) {
import org.tizen.dynamicanalyzer.ui.memory.table.MemoryAllocationTraceTable.MemoryAllocationTraceTableIndex;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
-import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotIntervalMarker;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotMarker;
@Override
public void widgetSelected(SelectionEvent e) {
- long t = System.nanoTime(); // TODO: this instruction required to
- // analyze performance and must be removed.
if (!(e.widget instanceof Grid))
return;
GridItem[] items = ((Grid) e.widget).getSelection();
DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) marker;
intervalMarker.setInterval(eventStartTime_sec, eventEndTime_sec);
chartBoard.getMemoryChartList().get(0).getChart().redraw();
- Logger.debug("Time spent for cross-focusing (nano) = "
- + (System.nanoTime() - t)); // TODO: this instruction required to
- // analyze performance and must be removed.
}
}
\ No newline at end of file
private MemoryAllocationTraceTable tableComp = null;
- private boolean tableUpdate;
private boolean firstUpdate;
private boolean tableVisible;
Composite contents = getContentArea();
contents.setLayout(new FillLayout());
- tableUpdate = false;
tableVisible = false;
firstUpdate = true;
if(DAState.isRunning() == false) {
if(firstUpdate == true) {
firstUpdate = false;
- tableUpdate = true;
tableVisible = true;
}
}
tableComp.setColumnVisibility(columnVisibilityDisable);
}
- if(tableUpdate == true) {
- tableComp.updateTable();
- tableUpdate = false;
- }
+ tableComp.updateTable();
}
@Override
if(selData.getStartTime() == selData.getEndTime()) {
tableComp.setSelectionRange((long)0, (long)0);
- tableUpdate = !DAState.isRunning();
if(DAState.isRunning()) {
tableVisible = false;
}
else {
tableComp.setSelectionRange(selData.getStartTime(), selData.getEndTime());
- tableUpdate = true;
tableVisible = true;
}
}
tableComp.updateTable();
- tableUpdate = false;
}
@Override
public void clear() {
tableComp.clear();
- tableUpdate = false;
firstUpdate = true;
tableVisible = false;
}
private void resizePageButton() {
int width = WorkbenchUtil.getWorkbenchWindow().getShell().getBounds().width;
- int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTarget().getTargetName()).size();
+ int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTargetOrSelected().getTargetName()).size();
int newWidth = (width/pageCount > DATabComposite.LONG_TAB_WIDTH) ? DATabComposite.LONG_TAB_WIDTH : width/pageCount;
((BaseView)WorkbenchUtil.getViewPart(BaseView.ID)).getMainTab().updateTabButtonsWidth(newWidth);
import java.util.List;\r
import java.util.Map;\r
\r
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
import org.tizen.dynamicanalyzer.common.Global;\r
import org.tizen.dynamicanalyzer.nl.MemoryPageLabels;\r
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;\r
private List<DAChartBoardItem> childBoardItemList = new ArrayList<DAChartBoardItem>();\r
\r
private DAChartBoardItem parentBoardItem;\r
- private static final int appAllocSeriesID = -10;\r
\r
private int libId;\r
private String libName;\r
chartIcon = ImageResources.FEATURE_HEAPALLOC_SMALL_NOR;\r
addIcon = ImageResources.FEATURE_HEAPALLOC_SMALL_NOR;\r
\r
- if(libId == appAllocSeriesID) {\r
+ if (libId == AnalyzerConstants.MAIN_EXECUTABLE_ID) {\r
totalSeries = new DAChartSeries(\r
String.format(TimelineChartLabels.HEAP_CHART_SERIES_NAME_PROCESS,\r
TimelineChartLabels.HEAP_CHART_SERIES_NAME_TOTAL_ALLOCATION),\r
int libId = (int) row.get(MemAllocDBTable.COLUMN.CALLER_LIBRARY_ID.index);\r
int pid = (int) row.get(MemAllocDBTable.COLUMN.PID.index);\r
\r
+ String entryName = Global.getLibraryName(libId);\r
+ if (entryName.equals(Global.getProject().getApplicationInfo().getExecPath()))\r
+ libId = AnalyzerConstants.MAIN_EXECUTABLE_ID;\r
+\r
// do not draw any excessive data\r
if (time >= endTime)\r
break;\r
private int allProcessPID = 0;\r
private int preSelectedPID = -1;\r
\r
- private final int appAllocSeriesID = -10;\r
- \r
private Set<String> targetChartList = null;\r
private List<List<Object>> persistentData = null;\r
private boolean showPersistentSeries = false;\r
private void initializeMemoryCharts() {\r
memoryChartList.clear();\r
\r
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();\r
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();\r
targetChartList = SettingDataManager.INSTANCE.getSelectedChartSet(target.getTargetName());\r
\r
for (int i = 0; i < memoryChartList.size(); i++) {\r
}\r
\r
private String getLibNameByID(int id) {\r
- if(id == appAllocSeriesID) {\r
+ if (id == AnalyzerConstants.MAIN_EXECUTABLE_ID) {\r
return MemoryPageLabels.MEMORY_MAIN_EXCUTABLE;\r
}\r
else {\r
}\r
\r
private void addHeapChartItemList(int pid, int libId) {\r
- if(libId == appAllocSeriesID) {\r
+ if (libId == AnalyzerConstants.MAIN_EXECUTABLE_ID) {\r
addHeapParentChartItemList(pid, libId);\r
} else {\r
MemoryChart parent = getParentHeapChart(pid, libId);\r
for(MemoryChart chart : memoryChartList) {\r
if(chart instanceof HeapMemoryChart && \r
chart.getPid() == pid &&\r
- ((HeapMemoryChart) chart).getLibId() == appAllocSeriesID) {\r
+ ((HeapMemoryChart) chart).getLibId() == AnalyzerConstants.MAIN_EXECUTABLE_ID) {\r
return chart;\r
}\r
}\r
private String getTargetPIDString(){\r
List<Integer> pidlist = new ArrayList<Integer>();\r
\r
+ if (Global.getProject() == null)\r
+ return "(0)";\r
+\r
int[] pids = Global.getProject().getProcessIDs();\r
int targetPID = Toolbar.INSTANCE.getSelectedPid();\r
\r
}
}
- String pidliststring = "(";
+ StringBuilder pidliststring = new StringBuilder();
+ pidliststring.append("(");
for(int i = 0 ; i < pidlist.size() ; i++) {
- pidliststring += Integer.toString(pidlist.get(i));
+ pidliststring.append(Integer.toString(pidlist.get(i)));
if(i != pidlist.size() - 1) {
- pidliststring += ", ";
+ pidliststring.append(", ");
}
}
- pidliststring += ")";
+ pidliststring.append(")");
- return pidliststring;
+ return pidliststring.toString();
}
private Logs getLogsFromLogPackage(LogPackage logPack, int logCenterConstants) {
dbFreeData.add(Integer.valueOf(pid));
dbFreeData.add(Integer.valueOf(mData.getMsgID()));
dbFreeData.add(Long.valueOf(mData.getTime()));
- dbFreeData.add(Long.valueOf(address));
+ dbFreeData.add(address);
dbFreeData.add(Integer.valueOf(binaryid));
memoryfreeDataList.add(dbFreeData);
@Override
public int compare(LogData arg0, LogData arg1) {
- return ((Long)arg0.getSeq()).compareTo((Long)arg1.getSeq());
+ return Long.compare(arg0.getSeq(), arg1.getSeq());
}
}
import java.sql.SQLException;\r
import java.util.ArrayList;\r
import java.util.HashMap;\r
-import java.util.Iterator;\r
import java.util.List;\r
import java.util.Map;\r
\r
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
import org.tizen.dynamicanalyzer.common.Global;\r
import org.tizen.dynamicanalyzer.constant.CommonConstants;\r
import org.tizen.dynamicanalyzer.database.DBInserter;\r
private static final int MEM_API_TYPE_ALLOC = 0;\r
private static final int MEM_API_TYPE_FREE = 1;\r
\r
- private static final int appAllocSeriesID = -10;\r
- \r
private int REALLOC_ID;\r
\r
// Map<PID, target Allocation Byte>\r
String appname = Global.getCurrentDeviceInfo().getSelectedPackageLabel();\r
\r
if(log.getLibName().endsWith(appname)) {\r
- binaryId = appAllocSeriesID;\r
+ binaryId = AnalyzerConstants.MAIN_EXECUTABLE_ID;\r
}\r
\r
if(REALLOC_ID == log.getApiId()) {\r
try {\r
long allocsize = log.getSize();\r
\r
- if (binaryId == appAllocSeriesID) {\r
+ if (binaryId == AnalyzerConstants.MAIN_EXECUTABLE_ID) {\r
mainAllocByteMap.put(pid, mainAllocByteMap.get(pid) + allocsize);\r
} else {\r
Long libraryAllocByte;\r
if(libraryAllocByteMap.get(pid).containsKey(binaryId)) {\r
libraryAllocByte = libraryAllocByteMap.get(pid).get(binaryId);\r
if (libraryAllocByte == null) {\r
- libraryAllocByte = new Long(0);\r
+ libraryAllocByte = 0L;\r
}\r
}\r
else {\r
- libraryAllocByte = new Long(0);\r
+ libraryAllocByte = 0L;\r
}\r
\r
libraryAllocByteMap.get(pid).put(binaryId,libraryAllocByte + allocsize);\r
if(allocsize == -1)\r
return;\r
\r
- if (alloclib == appAllocSeriesID) {\r
+ if (alloclib == AnalyzerConstants.MAIN_EXECUTABLE_ID) {\r
Long allocByte = mainAllocByteMap.get(pid);\r
mainAllocByteMap.put(pid, allocByte - allocsize);\r
} else {\r
libraryAllocByteMap.get(pid).put(alloclib,calsize);\r
}\r
else {\r
- libraryAllocByte = new Long(0);\r
+ libraryAllocByte = 0L;\r
libraryAllocByteMap.get(pid).put(alloclib,libraryAllocByte);\r
}\r
}\r
int memApiType = logData.getMemoryApiType();\r
\r
if (mainAllocByteMap.get(pid) == null) {\r
- mainAllocByteMap.put(Integer.valueOf(pid), new Long(0));\r
+ mainAllocByteMap.put(Integer.valueOf(pid), 0L);\r
libraryAllocByteMap.put(Integer.valueOf(pid), new HashMap<Integer, Long>());\r
}\r
\r
if (processLoad == null || processLoad.isEmpty()) {\r
continue;\r
}\r
- pIDList.add(new Integer(processLoad));\r
+ pIDList.add(Integer.parseInt(processLoad));\r
processLoadList.add(processLoadDatas[++ii]);\r
}\r
\r
* Make SystemData Table data\r
*/\r
ArrayList<Object> dbSystemData = new ArrayList<Object>();\r
- dbSystemData.add(new Long(log.getTime()));\r
- dbSystemData.add(new Long(log.getSystemMemoryUsed()));\r
+ dbSystemData.add(Long.valueOf(log.getTime()));\r
+ dbSystemData.add(Long.valueOf(log.getSystemMemoryUsed()));\r
dbSystemData.add(pIDList);\r
dbSystemData.add(processLoadList);\r
systemDataList.add(dbSystemData);\r
\r
List<Object> binaryIDList = new ArrayList<Object>();\r
List<Object> allocByteList = new ArrayList<Object>();\r
- binaryIDList.add(appAllocSeriesID);\r
if (mainAllocByteMap.get(process.getPid()) == null) {\r
allocByteList.add(new Long(0));\r
} else {\r
libraryList = new HashMap<Integer, Long>();\r
}\r
\r
- Iterator<Integer> iter = libraryList.keySet().iterator();\r
- while (iter.hasNext()) {\r
- Integer binaryID = iter.next();\r
- binaryIDList.add(binaryID);\r
- allocByteList.add(libraryList.get(binaryID));\r
+ for (Map.Entry<Integer, Long> entry: libraryList.entrySet()) {\r
+ binaryIDList.add(entry.getKey());\r
+ allocByteList.add(entry.getValue());\r
}\r
\r
/*\r
threadLoadList.add(threadLoads[++iii]);\r
}\r
\r
- dbTargetProcessData.add(new Long(log.getTime()));\r
- dbTargetProcessData.add(new Integer(process.getPid()));\r
- dbTargetProcessData.add(new Float(process.getProcessLoad()));\r
- dbTargetProcessData.add(new Long(process.getVirtualMemory()));\r
- dbTargetProcessData.add(new Long(process.getResidentMemory()));\r
- dbTargetProcessData.add(new Long(process.getSharedMemory()));\r
- dbTargetProcessData.add(new Long(process.getPssMemory()));\r
+ dbTargetProcessData.add(Long.valueOf(log.getTime()));\r
+ dbTargetProcessData.add(Integer.valueOf(process.getPid()));\r
+ dbTargetProcessData.add(Float.valueOf(process.getProcessLoad()));\r
+ dbTargetProcessData.add(Long.valueOf(process.getVirtualMemory()));\r
+ dbTargetProcessData.add(Long.valueOf(process.getResidentMemory()));\r
+ dbTargetProcessData.add(Long.valueOf(process.getSharedMemory()));\r
+ dbTargetProcessData.add(Long.valueOf(process.getPssMemory()));\r
// for new version\r
- dbTargetProcessData.add(new Long(process.getThreeDMemory()));\r
- dbTargetProcessData.add(new Long(process.getGemMemory()));\r
+ dbTargetProcessData.add(Long.valueOf(process.getThreeDMemory()));\r
+ dbTargetProcessData.add(Long.valueOf(process.getGemMemory()));\r
\r
- dbTargetProcessData.add(new Integer(process.getThreadCount()));\r
- dbTargetProcessData.add(new Long(process.getTotalAllocSize()));\r
+ dbTargetProcessData.add(Integer.valueOf(process.getThreadCount()));\r
+ dbTargetProcessData.add(Long.valueOf(process.getTotalAllocSize()));\r
\r
dbTargetProcessData.add(binaryIDList);\r
dbTargetProcessData.add(allocByteList);\r
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.ui.widgets.table.DefaultTableComparator;
import org.tizen.dynamicanalyzer.ui.widgets.table.TableColumnSizePackListener;
-import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.timeline.MarkerManager;
public class MemoryAllocationTraceTable extends DATableComposite {
@Override
public void widgetSelected(SelectionEvent e) {
- long t = System.nanoTime();// TODO: this instruction required to
- // analyze performance and must be removed.
GridItem[] items = ((Grid) e.widget).getSelection();
if (null == items|| items.length == 0) {
return;
DASelectionData data = new DASelectionData(MemoryPage.allocationtraceViewID, startTime,
endTime, items, table);
AnalyzerManager.getCurrentPage().updateView(data);
- Logger.debug("Time spent for update of memory page(nano) = "
- + (System.nanoTime() - t));// TODO: this instruction required to
- // analyze performance and must be removed.
}
@Override
}
});
+
+ initFilterPopupMenu();
}
public void setSelectionRange(Long start, Long end){
if(Global.getProject() == null) {
return output;
}
-
+
+ if (isFilter) {
+ output = filteredTable;
+ return output;
+ }
+
if(DAState.isRunning() == false) {
if(StartTime == 0 && EndTime == 0 && Toolbar.INSTANCE.getSelectedPid() <= 0) {
List<TableInput> wholedata = HeapDataManager.getInstance().getWholeAllocationTraceTreeInput();
if(wholedata.size() != 0) {
+ tableClone = wholedata;
return wholedata;
}
}
output.add(alloInput);
}
}
-
+ tableClone = output;
return output;
}
import java.util.List;\r
import java.util.Map;\r
\r
-import org.eclipse.nebula.widgets.grid.GridItem;\r
import org.eclipse.swt.SWT;\r
import org.eclipse.swt.widgets.Composite;\r
-import org.eclipse.swt.widgets.Event;\r
-import org.eclipse.swt.widgets.Listener;\r
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
import org.tizen.dynamicanalyzer.common.Global;\r
import org.tizen.dynamicanalyzer.model.TreeInput;\r
comparator.setColumn(0);\r
\r
parent.addControlListener(new TableColumnSizePackListener(this, columnSizes));\r
- \r
- table.addListener(SWT.Expand, new Listener() {\r
-\r
- @Override\r
- public void handleEvent(Event event) {\r
- GridItem item = (GridItem) event.item;\r
- setExpand(item, true);\r
- }\r
- });\r
-\r
- table.addListener(SWT.Collapse, new Listener() {\r
- @Override\r
- public void handleEvent(Event event) {\r
- GridItem item = (GridItem) event.item;\r
- setExpand(item, false);\r
- }\r
- });\r
}\r
\r
public void setSelectionRange(Long start, Long end, Long current) {\r
for(Map.Entry<Integer, List<Long>> entry : heapdata.entrySet()) {\r
int binaryId = entry.getKey();\r
String libname;\r
- \r
- // -10 == target application\r
- if(binaryId == -10) {\r
+\r
+ if (binaryId == AnalyzerConstants.MAIN_EXECUTABLE_ID) {\r
libname = MemoryPageLabels.MEMORY_MAIN_EXCUTABLE;\r
}\r
else {\r
*
* Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
- * Contact:
+ * Contact:
* Dongkye Lee <dongkyu6.lee@samsung.com>
* Jaeyong Lee <jae-yong.lee@@samsung.com>
* Gihun Chang <gihun.chang@@samsung.com>
+ * Vladislav Eliseev <v.eliseev@samsung.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* 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 org.tizen.dynamicanalyzer.ui.memory.table;
import org.eclipse.swt.widgets.Composite;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.Global;
-import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.model.TreeInput;
import org.tizen.dynamicanalyzer.nl.MemoryPageLabels;
import org.tizen.dynamicanalyzer.project.LibraryObject;
import org.tizen.dynamicanalyzer.project.ProcessMemoryMap;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.ui.toolbar.Toolbar;
-import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
+import org.tizen.dynamicanalyzer.ui.widgets.table.DATreeComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DefaultTableComparator;
import org.tizen.dynamicanalyzer.ui.widgets.table.TableColumnSizePackListener;
-public class MemoryMapTable extends DATableComposite {
+public class MemoryMapTable extends DATreeComposite {
+
+ /**
+ * Index for table rows.
+ */
+ int keyindex = 0;
public MemoryMapTable(Composite parent, int style, int tableStyle) {
super(parent, style, tableStyle);
setTableName(MemoryPageLabels.MEMORY_MAP_VIEW_TITLE);
setComparator(new DefaultTableComparator());
-
- setSortTypes(new int[] { AnalyzerConstants.SORT_TYPE_STRING, AnalyzerConstants.SORT_TYPE_NUM,
- AnalyzerConstants.SORT_TYPE_STRING, AnalyzerConstants.SORT_TYPE_NUM,
- AnalyzerConstants.SORT_TYPE_NUM, AnalyzerConstants.SORT_TYPE_NONE });
- setColumnAlignment(new int[] { SWT.CENTER, SWT.RIGHT, SWT.LEFT, SWT.RIGHT, SWT.RIGHT, SWT.LEFT });
+ setTree(true);
+
+ setSortTypes(new int[] { AnalyzerConstants.SORT_TYPE_STRING,
+ AnalyzerConstants.SORT_TYPE_STRING,
+ AnalyzerConstants.SORT_TYPE_NUM,
+ AnalyzerConstants.SORT_TYPE_NUM,
+ AnalyzerConstants.SORT_TYPE_NUM,
+ AnalyzerConstants.SORT_TYPE_NONE });
- setColumns(new String[] {
+ setColumnAlignment(new int[] { SWT.LEFT, SWT.CENTER, SWT.RIGHT,
+ SWT.RIGHT, SWT.RIGHT, SWT.LEFT });
+
+ setColumns(new String[] { MemoryPageLabels.MEMORY_MEMORYMAP_LIBNAME,
MemoryPageLabels.MEMORY_MEMORYMAP_TYPE,
MemoryPageLabels.MEMORY_MEMORYMAP_SIZE,
- MemoryPageLabels.MEMORY_MEMORYMAP_LIBNAME,
MemoryPageLabels.MEMORY_MEMORYMAP_ADDRESS_LOW,
MemoryPageLabels.MEMORY_MEMORYMAP_ADDRESS_HIGH,
- ""
- });
+ "" });
- int[] columnSizes = { 40, 60, 150, 80, 80, 5 };
+ int[] columnSizes = { 150, 40, 60, 80, 80, 5 };
setColumnSize(columnSizes);
- setColumnVisibility(new boolean[] { true, true, true, true, true, true });
-
+ setColumnVisibility(
+ new boolean[] { true, true, true, true, true, true });
+
setTableToolTipEnable(false);
-
+
comparator.setType(AnalyzerConstants.SORT_TYPE_NUM);
- comparator.setColumn(1);
- comparator.setDirection(false);
-
- parent.addControlListener(new TableColumnSizePackListener(this, columnSizes));
+ comparator.setColumn(3);
+
+ parent.addControlListener(
+ new TableColumnSizePackListener(this, columnSizes));
}
-
- @Override
- protected List<TableInput> makeTableInput() {
- List<TableInput> output = new ArrayList<TableInput>();
- List<Integer> pidlist = new ArrayList<Integer>();
- if(Global.getProject() == null) {
- return output;
- }
+ /**
+ * Get target processes pids which should be displayed.
+ */
+ private List<Integer> getPidList() {
+ List<Integer> result = new ArrayList<>();
int[] pids = Global.getProject().getProcessIDs();
int targetPID = Toolbar.INSTANCE.getSelectedPid();
- if(targetPID > 0) {
- pidlist.add(targetPID);
- }
- else {
+ if (targetPID > 0) {
+ result.add(targetPID);
+ } else {
for (int i = 0; i < pids.length; i++) {
- pidlist.add(pids[i]);
- }
+ result.add(pids[i]);
+ }
}
-
+
+ return result;
+ }
+
+ @Override
+ public List<TreeInput> makeTreeInput() {
+ keyindex = 0;
Project project = Global.getProject();
- int index = 0;
+ List<TreeInput> output = new ArrayList<>();
+
+ if (project == null) {
+ return output;
+ }
+
+ List<Integer> pidList = getPidList();
+
+ // for every pid
+ for (Integer pid : pidList) {
+ TreeInput parentInput = makeProcessHeaderTreeInput(pid);
+
+ ProcessMemoryMap pmap = project.getProcessInformation(pid)
+ .getLastProcessMemoryMap();
- for(int i = 0 ; i < pidlist.size() ; i++) {
-
- ProcessMemoryMap pmap = project.getProcessInformation(pidlist.get(i)).getLastProcessMemoryMap();
-
Map<Integer, LibraryObject> binarymap = pmap.getAllLibraryID();
-
- for(Map.Entry<Integer, LibraryObject> entry : binarymap.entrySet()) {
- String binPath = project.getDeviceStatusInfo().getBinaryInfo(entry.getValue().getBinaryID()).getTargetBinaryPath();
-
- TableInput mapInput = makeTreeInput(binPath,
- entry.getValue().getLowestAddress(), entry.getValue().getHighestAddress(), index++);
-
- if (mapInput != null && !output.contains(mapInput)){
- output.add(mapInput);
- }
+
+ // for every library
+ for (Map.Entry<Integer, LibraryObject> entry : binarymap.entrySet()) {
+ int binId = entry.getKey();
+ String binPath = project.getDeviceStatusInfo()
+ .getBinaryInfo(binId).getTargetBinaryPath();
+
+ TreeInput mapInput = makeMapEntryTreeInput(binPath, entry.getValue());
+
+ parentInput.addChild(mapInput);
}
+
+ output.add(parentInput);
}
return output;
}
-
- private TableInput makeTreeInput(String binarypath, long low, long high, int index) {
- DATableDataFormat tableData = new DATableDataFormat(index);
-
- List<String> text = new ArrayList<String>();
- List<Object> data = new ArrayList<Object>();
-
- Long Low = (Long) low;
- Long High = (Long) high;
+
+ /**
+ * Make tree input for process header.
+ *
+ * @param pid process identifier
+ */
+ private TreeInput makeProcessHeaderTreeInput(int pid) {
+ DATableDataFormat tableData = new DATableDataFormat(keyindex++);
+
+ List<String> text = new ArrayList<>();
+ List<Object> data = new ArrayList<>();
+
+ String headerCaption = String.format("PID #%d", pid);
+ // PID column
+ text.add(headerCaption);
+ data.add(pid);
+
+ // type
+ text.add("");
+ data.add("");
+
+ // rest columns
+ for (int i = 2; i < columnNames.length; i++) {
+ text.add("");
+ data.add(new Long(0));
+ }
+
+ TreeInput output = new TreeInput();
+ output.setText(text);
+ tableData.setData(data);
+ tableData.setObject(headerCaption);
+
+ output.setData(tableData);
+
+ return output;
+ }
+
+ /**
+ * Make tree input for library mapping.
+ *
+ * @param binPath library binary path
+ * @param libObj library object
+ */
+ private TreeInput makeMapEntryTreeInput(String binPath, LibraryObject libObj) {
+ DATableDataFormat tableData = new DATableDataFormat(keyindex++);
+
+ List<String> text = new ArrayList<>();
+ List<Object> data = new ArrayList<>();
+
+ Long Low = libObj.getLowestAddress();
+ Long High = libObj.getHighestAddress();
Long size = High - Low;
-
+
+ // bin path
+ text.add(binPath);
+ data.add(binPath);
+
+ // type
text.add("r-x-");
data.add("r-x-");
-
+
+ // size
text.add(Long.toString(size));
data.add(size);
-
- text.add(binarypath);
- data.add(binarypath);
-
+
+ // low address
text.add("0x" + Long.toHexString(Low));
- data.add(Low);
-
+ data.add(Low);
+
+ // high address
text.add("0x" + Long.toHexString(High));
data.add(High);
TreeInput output = new TreeInput();
output.setText(text);
- tableData.getData().addAll(data);
+ tableData.setData(data);
+ tableData.setObject(binPath);
output.setData(tableData);
return output;
}
-
}
import java.util.ArrayList;\r
import java.util.List;\r
\r
-import org.eclipse.nebula.widgets.grid.GridItem;\r
import org.eclipse.swt.SWT;\r
import org.eclipse.swt.widgets.Composite;\r
-import org.eclipse.swt.widgets.Event;\r
-import org.eclipse.swt.widgets.Listener;\r
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
import org.tizen.dynamicanalyzer.common.Global;\r
import org.tizen.dynamicanalyzer.model.TreeInput;\r
comparator.setColumn(1);\r
parent.addControlListener(new TableColumnSizePackListener(this, columnSizes));\r
-\r
- table.addListener(SWT.Expand, new Listener() {\r
-\r
- @Override\r
- public void handleEvent(Event event) {\r
- GridItem item = (GridItem) event.item;\r
- setExpand(item, true);\r
- }\r
- });\r
-\r
- table.addListener(SWT.Collapse, new Listener() {\r
- @Override\r
- public void handleEvent(Event event) {\r
- GridItem item = (GridItem) event.item;\r
- setExpand(item, false);\r
- }\r
- });\r
}\r
public void setSelectionRange(Long start, Long end){
private void resizePageButton() {
int width = WorkbenchUtil.getWorkbenchWindow().getShell().getBounds().width;
- int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTarget().getTargetName()).size();
+ int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTargetOrSelected().getTargetName()).size();
int newWidth = (width/pageCount > DATabComposite.LONG_TAB_WIDTH) ? DATabComposite.LONG_TAB_WIDTH : width/pageCount;
((BaseView)WorkbenchUtil.getViewPart(BaseView.ID)).getMainTab().updateTabButtonsWidth(newWidth);
private void resizePageButton() {
int width = WorkbenchUtil.getWorkbenchWindow().getShell().getBounds().width;
- int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTarget().getTargetName()).size();
+ int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTargetOrSelected().getTargetName()).size();
int newWidth = (width/pageCount > DATabComposite.LONG_TAB_WIDTH) ? DATabComposite.LONG_TAB_WIDTH : width/pageCount;
((BaseView)WorkbenchUtil.getViewPart(BaseView.ID)).getMainTab().updateTabButtonsWidth(newWidth);
MemoryChartView chartView = (MemoryChartView) AnalyzerUtil.getView(MemoryPage.pageID,
MemoryChartView.class.getName());
- if (chartView != null)
+ if (chartView != null) {
((MemoryChartBoard) chartView.getChartBoard()).showPersistentSeries(source.getSelection());
+ chartView.updateView();
+ }
}
((TimelinePage)AnalyzerUtil.getTabPage(TimelinePage.pageID)).resizeTableButton();
}
Map<Integer, CurrentLeakData> leaks = leakDetector.getLeakHash();
List<List<Object>> leakDataList = new ArrayList<List<Object>>();
- for (Integer key : leaks.keySet()) {
- CurrentLeakData input = leaks.get(key);
+ for (Map.Entry<Integer, CurrentLeakData> entry : leaks.entrySet()) {
+ CurrentLeakData input = entry.getValue();
if (input == null) {
continue;
}
public List<List<Object>> getLeakDataWithSeq(List<Long> leakSequenceNumbers,
List<String> whereQueryList) {
- String where = String.format(query_withSeqList,
- MemoryAllocationDataDBTable.COLUMN.SEQUENCE_NUMBER.name);
+ StringBuilder where = new StringBuilder();
+ where.append(String.format(query_withSeqList,
+ MemoryAllocationDataDBTable.COLUMN.SEQUENCE_NUMBER.name));
int size = leakSequenceNumbers.size();
for (int i = 0; i < size - 1; i++) {
- where += String.valueOf(leakSequenceNumbers.get(i)) + CommonConstants.COMMA
- + CommonConstants.SPACE;
+ where.append(String.valueOf(leakSequenceNumbers.get(i)));
+ where.append(CommonConstants.COMMA);
+ where.append(CommonConstants.SPACE);
}
- where += String.valueOf(leakSequenceNumbers.get(size - 1)) + CommonConstants.CLOSE_BRACKET;
+ where.append(String.valueOf(leakSequenceNumbers.get(size - 1)));
+ where.append(CommonConstants.CLOSE_BRACKET);
if (whereQueryList != null && !whereQueryList.isEmpty()) {
// if 'WHERE' condition used on the DB query is existed
for (int i = 0; i < whereQueryList.size(); i++) {
- where += " and " + whereQueryList.get(i);
+ where.append(" and ");
+ where.append(whereQueryList.get(i));
}
}
- return executeQuery(where);
+ return executeQuery(where.toString());
}
public List<List<Object>> getLeakDataForRange() {
int pid) {
String where = String.format(query_withPidAndTime,
MemoryAllocationDataDBTable.COLUMN.PID.name,
- Integer.valueOf(pid).toString(),
+ Integer.toString(pid),
MemoryAllocationDataDBTable.COLUMN.ALLOCATED_TIME.name, startTime.toString(),
MemoryAllocationDataDBTable.COLUMN.ALLOCATED_TIME.name, endTime.toString(),
MemoryAllocationDataDBTable.COLUMN.ALLOCATED_TIME.name);
private List<List<Object>> getFreeDataWithPidFromDBForRange(Long startTime, Long endTime,
int pid) {
String where = String.format(query_withPidAndTime, FreeDataDBTable.COLUMN.PID.name,
- Integer.valueOf(pid).toString(), FreeDataDBTable.COLUMN.FREE_TIME.name,
+ Integer.toString(pid),
+ FreeDataDBTable.COLUMN.FREE_TIME.name,
startTime.toString(), FreeDataDBTable.COLUMN.FREE_TIME.name, endTime.toString(),
FreeDataDBTable.COLUMN.FREE_TIME.name);
DBTable table = SummaryDataManager.getInstance().getFreeDataDBTable();
// }
private boolean isDropLog(LogData logData) {
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
int id = logData.getMsgID();
switch (id) {
case ProtocolConstants.MSG_PROBE_FILE:
// String inputParam = input[LogCenterConstants.INPUTPARM_INDEX];
String inputParam = ((ProbeCommonData) log).getArgs();
String[] splitInputParam = inputParam.split("\\,"); //$NON-NLS-1$
- String param = new String(splitInputParam[0]);
+ String param = splitInputParam[0];
long rmKey = -1;
try {
if (param.contains("0x")) {
import java.util.Map;
import org.eclipse.nebula.widgets.grid.GridItem;
-import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Listener;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
super(parent, compStyle, tableStyle);
setContextMenu(AnalyzerConstants.CONTEXT_TABLE_RANGE);
- table.addListener(SWT.Expand, new Listener() {
-
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, true);
- }
- });
- table.addListener(SWT.Collapse, new Listener() {
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, false);
- }
- });
-
table.addSelectionListener(new SelectionListener() {
@Override
// Feature On : false, Feature Off : true
private boolean isDropLog(LogData logData) {
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
ProbeCommonData pData = (ProbeCommonData) logData;
if (!pData.isInternal()) return false;
if (target.isSelectedFeature(Feature.INTERNAL_PROBE_MEMORY)) {
}
private int findAllocatedKey(Map<Integer, CurrentLeakData> leaks, long addr, int pid) {
- for (Integer key : leaks.keySet()) {
- CurrentLeakData iLeakData = leaks.get(key);
- if (iLeakData.getAllocatedValue() == addr && iLeakData.getPid() == pid) {
- return key;
+ for (Map.Entry<Integer, CurrentLeakData> entry : leaks.entrySet()) {
+ if (entry.getValue().getAllocatedValue() == addr
+ && entry.getValue().getPid() == pid) {
+ return entry.getKey();
}
}
@Override
protected void makeData(LogPackage pack) {
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
// TODO: will get sample_time from Project.java
if (!isSetSamplePeriod) {
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Listener;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
setTableName(SummaryLabels.FUNCTION_USER_PROFILING_VIEW_TITLE);
parent.addControlListener(new TableColumnSizePackListener(this, columnSizes));
- table.addListener(SWT.Expand, new Listener() {
-
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, true);
- }
- });
-
- table.addListener(SWT.Collapse, new Listener() {
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, false);
- }
- });
-
table.addSelectionListener(new SelectionListener() {
@Override
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Listener;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
setTableName(SummaryLabels.FUNCTION_USER_PROFILING_VIEW_TITLE);
parent.addControlListener(new TableColumnSizePackListener(this, columnSizes));
- table.addListener(SWT.Expand, new Listener() {
-
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, true);
- }
- });
-
- table.addListener(SWT.Collapse, new Listener() {
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, false);
- }
- });
-
table.addSelectionListener(new SelectionListener() {
@Override
private void resizePageButton() {
int width = WorkbenchUtil.getWorkbenchWindow().getShell().getBounds().width;
- int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTarget().getTargetName()).size();
+ int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTargetOrSelected().getTargetName()).size();
int newWidth = (width/pageCount > DATabComposite.LONG_TAB_WIDTH) ? DATabComposite.LONG_TAB_WIDTH : width/pageCount;
((BaseView)WorkbenchUtil.getViewPart(BaseView.ID)).getMainTab().updateTabButtonsWidth(newWidth);
private void resizePageButton() {
int width = WorkbenchUtil.getWorkbenchWindow().getShell().getBounds().width;
- int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTarget().getTargetName()).size();
+ int pageCount = PageInfoRegistry.getPageNamesByTarget(SettingDataManager.INSTANCE.getConnectedTargetOrSelected().getTargetName()).size();
int newWidth = (width/pageCount > DATabComposite.LONG_TAB_WIDTH) ? DATabComposite.LONG_TAB_WIDTH : width/pageCount;
((BaseView)WorkbenchUtil.getViewPart(BaseView.ID)).getMainTab().updateTabButtonsWidth(newWidth);
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.nl.TimelinePageLabels;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
-import org.tizen.dynamicanalyzer.project.ProcessInformation;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.ui.toolbar.Toolbar;
+import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
-import org.tizen.dynamicanalyzer.ui.widgets.table.DAWindowingTableComposite;
-import org.tizen.dynamicanalyzer.ui.widgets.table.WindowingTableColumnSizePackListener;
import org.tizen.dynamicanalyzer.utils.Formatter;
import org.tizen.dynamicanalyzer.widgets.timeline.MarkerManager;
-public class CallTraceTable extends DAWindowingTableComposite {
+public class CallTraceTable extends DATableComposite {
// disable parameter and return column until we can get those values
private String[] columnNames = { TimelinePageLabels.CALL_TRACE_VIEW_TIME,
TimelinePageLabels.CALL_TRACE_VIEW_TID, TimelinePageLabels.CALL_TRACE_VIEW_PID,
setColumnSize(columnSizes);
setColumnVisibility(columnVisibility);
setItemHeightSize(16);
- parent.addControlListener(new WindowingTableColumnSizePackListener(this, columnSizes));
-
- setDataType(FunctionEntryDBTable.COLUMN.START_TIME.index); // use new DB
setContextMenu(AnalyzerConstants.CONTEXT_TABLE_SOURCE);
table.addSelectionListener(new SelectionListener() {
@Override
public void mouseUp(MouseEvent e) {
-
+
}
});
@Override
protected List<TableInput> makeTableInput() {
- List<List<Object>> queriedData = getQueriedObjectData();
- List<TableInput> input = new ArrayList<TableInput>();
+ List<List<Object>> queriedData = getFunctionEntryData();
+ List<TableInput> input = new ArrayList<>();
+
+ if (queriedData == null) {
+ return input;
+ }
+
int size = queriedData.size();
for (int i = 0; i < size; i++) {
List<Object> rowData = queriedData.get(i);
return input;
}
- protected String getDBTableName() {
- return CallTraceDataManager.getInstance().getFunctionEntryTable().getTableName();
- }
-
- protected List<String> getDBTableColumnNames() {
- List<String> columnName = new ArrayList<String>();
- columnName.add("*");
- return columnName;
- }
-
- public int getItemCountByPid() {
- if (null == Global.getProject()) {
- return 0;
- }
-
- int itemCount = 0;
- int selectedPid = Toolbar.INSTANCE.getSelectedPid();
- if (selectedPid != 0) {
- ProcessInformation process = Global.getProject().getProcessInformation(selectedPid);
- itemCount = process.getFunctionEntryLogCount();
- } else {
- itemCount = Global.getProject().getTotalFunctionEntryCount();
- }
- return itemCount;
- }
-
- protected String getSelectQueryOption() {
- StringBuffer query = new StringBuffer();
- int selectedPid = Toolbar.INSTANCE.getSelectedPid();
- if (selectedPid != 0) {
- query.append("pid =" + selectedPid);//$NON-NLS-1$
- }
- /*
- * ToDo need to revision query or windowing logic of windowing table
- */
- // query.append(" order by " + FunctionEntryDBTable.COLUMN.STARTTIME.name);
- return query.toString();
+ /**
+ * Get all function entry data from DB.
+ *
+ * @return list of rows, where row is list of objects,
+ * <code>null</code> if there is no required data in the DB
+ */
+ private List<List<Object>> getFunctionEntryData() {
+ return CallTraceDataManager.getInstance().getFunctionEntryTable().selectAllObjectData();
}
- protected String getSelectQueryCountOption() {
- StringBuffer query = new StringBuffer();
- int selectedPid = Toolbar.INSTANCE.getSelectedPid();
- if (selectedPid != 0) {
- query.append("pid =" + selectedPid);//$NON-NLS-1$
- }
- return query.toString();
- }
+ /**
+ * Select table items falling within specified time interval.
+ *
+ * @param selectionStartTime start of interval
+ * @param selectionEndTime end of interval
+ */
+ public void setSelectionByTime(final long selectionStartTime, final long selectionEndTime) {
+ setSelectionByPredicate(new Predicate<GridItem>() {
+ @Override
+ public boolean evaluate(GridItem item) {
+ DATableDataFormat gridData = (DATableDataFormat) item.getData();
+ if (gridData == null)
+ return false;
- @Override
- protected String getTimeColumnName() {
- return FunctionEntryDBTable.COLUMN.START_TIME.name;
+ long time = (Long) gridData.getData().get(FunctionEntryDBTable.COLUMN.START_TIME.index);
+ return selectionStartTime <= time && time <= selectionEndTime;
+ }
+ });
}
}
\ No newline at end of file
package org.tizen.dynamicanalyzer.ui.timeline.calltrace;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-
-import org.eclipse.nebula.widgets.grid.GridItem;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Control;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.common.Global;
-import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.nl.TimelinePageLabels;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.ui.info.callstack.CallstackView;
-import org.tizen.dynamicanalyzer.ui.interactive.InteractivePage;
-import org.tizen.dynamicanalyzer.ui.interactive.data.InteractiveUIData;
-import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
-import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineTableView;
-import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
-import org.tizen.dynamicanalyzer.ui.widgets.table.DAWindowingTableComposite;
-import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
-import org.tizen.dynamicanalyzer.widgets.da.view.DATabComposite;
+import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewData;
contents.setLayout(stackLayout);
nativeTable = new CallTraceTable(contents, SWT.NONE, SWT.MULTI
- | SWT.BORDER | SWT.FULL_SELECTION);
+ | SWT.BORDER | SWT.FULL_SELECTION | SWT.V_SCROLL | SWT.H_SCROLL);
nativeTable.setTableName(TimelinePageLabels.CALL_TRACE_VIEW_TITLE);
webTable = new WebCallTraceTable(contents, SWT.NONE, SWT.MULTI
- | SWT.BORDER | SWT.FULL_SELECTION);
+ | SWT.BORDER | SWT.FULL_SELECTION | SWT.V_SCROLL | SWT.H_SCROLL);
// select native or web table
Project currentProject = Global.getProject();
long start = selData.getStartTime();
long end = selData.getEndTime();
- updateView();
- // When Interactive Table's column is clicked
- if (selData.getViewID().equals(InteractivePage.listViewID)) {
- GridItem rootGridItem = findRootGridItem((GridItem)(selData.getData()));
- InteractiveUIData uiData = (InteractiveUIData)((DATableDataFormat)
- rootGridItem.getData()).getObject();
- long interactiveSeqNum = uiData.getSeq();
- int funcID = uiData.getVariableInfo().getFunctionID();
- start = findFuncCallTime(funcID, interactiveSeqNum);
- end = start;
- }
- ((DAWindowingTableComposite)stackLayout.topControl).setSelectionByTime(start, end);
- updateView();
-
- /* only callstack update */
+
if (stackLayout.topControl == nativeTable) {
- if (selData.getViewID().equals(TimelinePage.timelineViewID)) {
- DATabComposite tabView = (DATabComposite) AnalyzerUtil.getView(
- TimelinePage.pageID, TimelineTableView.tabID);
- if (tabView == null) {
- Logger.warning("Tabview does not exist.");
- } else {
- Composite comp = tabView.getTopComposite();
- if (comp instanceof CallstackView) {
- ((CallstackView) comp).updateView();
- }
- }
- }
+ nativeTable.setSelectionByTime(start, end);
+ } else {
+ webTable.setSelectionByTime(start, end);
}
+ updateView();
}
}
@Override
public void updateView() {
- ((DAWindowingTableComposite)stackLayout.topControl).updateTable();
+ ((DATableComposite)stackLayout.topControl).updateTable();
}
@Override
public void clear() {
- ((DAWindowingTableComposite)stackLayout.topControl).getTable().removeAll();
- ((DAWindowingTableComposite)stackLayout.topControl).clear();
+ ((DATableComposite)stackLayout.topControl).clear();
}
@Override
public Control getControl() {
return stackLayout.topControl;
}
-
- private GridItem findRootGridItem(GridItem gridItem) {
- if (gridItem.getParentItem() == null) {
- return gridItem;
- }
- return findRootGridItem(gridItem.getParentItem());
- }
-
- /*
- * Find function's call entry time concerning interactive profiling sequence number.
- */
- private long findFuncCallTime(int funcID, long interactiveSeqNum) {
- long callTime = 0;
- String query = String.format(FunctionEntryDBTable.FIND_ENTRY_TIME_QUERY, funcID, interactiveSeqNum);
- ResultSet rs = SqlConnectionManager.executeQueryRS(query);
- if (null == rs) {
- return callTime;
- }
- try {
- rs.next();
- callTime = rs.getLong(1);
- } catch (SQLException e) {
- Logger.exception(e);
- } finally {
- SqlConnectionManager.releaseResultSet(rs);
- }
- return callTime;
- }
}
import java.util.ArrayList;
import java.util.List;
+import org.eclipse.nebula.widgets.grid.GridItem;
import org.eclipse.swt.widgets.Composite;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.nl.TimelinePageLabels;
-import org.tizen.dynamicanalyzer.project.ProcessInformation;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
-import org.tizen.dynamicanalyzer.ui.toolbar.Toolbar;
+import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
-import org.tizen.dynamicanalyzer.ui.widgets.table.DAWindowingTableComposite;
-import org.tizen.dynamicanalyzer.ui.widgets.table.WindowingTableColumnSizePackListener;
import org.tizen.dynamicanalyzer.utils.Formatter;
-public class WebCallTraceTable extends DAWindowingTableComposite {
- private String[] columnNames = {
+public class WebCallTraceTable extends DATableComposite {
+ private String[] columnNames = {
TimelinePageLabels.CALL_TRACE_VIEW_TIME,
TimelinePageLabels.CALL_TRACE_VIEW_TID,
TimelinePageLabels.CALL_TRACE_VIEW_PID,
setColumnSize(columnSizes);
setColumnVisibility(columnVisibility);
setItemHeightSize(16);
- parent.addControlListener(new WindowingTableColumnSizePackListener(
- this, columnSizes));
-
- setDataType(WebFunctionEntryDBTable.COLUMN.START_TIME.getIndex()); // use new DB
}
@Override
protected List<TableInput> makeTableInput() {
- List<List<Object>> queriedData = getQueriedObjectData();
- List<TableInput> input = new ArrayList<TableInput>();
+ List<List<Object>> queriedData = getWebFunctionEntryData();
+ List<TableInput> input = new ArrayList<>();
+
+ if (queriedData == null) {
+ return null;
+ }
+
int size = queriedData.size();
for (int i = 0; i < size; i++) {
List<Object> rowData = queriedData.get(i);
List<String> contentText = new ArrayList<String>();
// START_TIME
- long time = (Long) rowData.get(WebFunctionEntryDBTable.COLUMN.START_TIME.getIndex());
+ long time = (Long) rowData.get(WebFunctionEntryDBTable.COLUMN.START_TIME.index);
contentText.add(Formatter.toTimeFormat(time));
// TID
- Integer tid = (Integer) rowData.get(WebFunctionEntryDBTable.COLUMN.TID.getIndex());
+ Integer tid = (Integer) rowData.get(WebFunctionEntryDBTable.COLUMN.TID.index);
contentText.add(Integer.toString(tid));
// PID
- Integer pid = (Integer) rowData.get(WebFunctionEntryDBTable.COLUMN.PID.getIndex());
+ Integer pid = (Integer) rowData.get(WebFunctionEntryDBTable.COLUMN.PID.index);
contentText.add(Integer.toString(pid));
// FUNCTION_NAME
- String functionName = (String) rowData.get(WebFunctionEntryDBTable.COLUMN.FUNCTION_NAME.getIndex());
+ String functionName = (String) rowData.get(WebFunctionEntryDBTable.COLUMN.FUNCTION_NAME.index);
contentText.add(functionName);
// FUNCTION_URL
- String functionURL = (String) rowData.get(WebFunctionEntryDBTable.COLUMN.FUNCTION_URL.getIndex());
+ String functionURL = (String) rowData.get(WebFunctionEntryDBTable.COLUMN.FUNCTION_URL.index);
int lastIndex = functionURL.lastIndexOf(CommonConstants.SLASH);
String fileName = functionURL.substring(lastIndex + 1);
contentText.add(fileName);
// FUNCTION_LINE_NUMBER
- Integer functionLineNumber = (Integer) rowData.get(WebFunctionEntryDBTable.COLUMN.FUNCTION_LINE_NUMBER.getIndex());
+ Integer functionLineNumber = (Integer) rowData.get(WebFunctionEntryDBTable.COLUMN.FUNCTION_LINE_NUMBER.index);
contentText.add(Integer.toString(functionLineNumber));
// create DATableDataFormat
DATableDataFormat tableData = new DATableDataFormat(
- (Long) rowData.get(WebFunctionEntryDBTable.COLUMN.SEQUENCE_NUMBER.getIndex()));
+ (Long) rowData.get(WebFunctionEntryDBTable.COLUMN.SEQUENCE_NUMBER.index));
tableData.getData().addAll(rowData);
tableData.setType(AnalyzerConstants.TYPE_TABLE_WEB_CALLTRACE);
}
return input;
}
-
- @Override
- protected String getDBTableName() {
- return CallTraceDataManager.getInstance().getWebFunctionEntryTable().getTableName();
- }
-
- @Override
- protected List<String> getDBTableColumnNames() {
- List<String> columnName = new ArrayList<String>();
- columnName.add("*");
- return columnName;
- }
-
- @Override
- protected int getItemCountByPid() {
- if (null == Global.getProject()) {
- return 0;
- }
- int itemCount = 0;
- int selectedPid = Toolbar.INSTANCE.getSelectedPid();
- if (selectedPid != 0) {
- ProcessInformation process = Global.getProject()
- .getProcessInformation(selectedPid);
- itemCount = process.getFunctionEntryLogCount();
- } else {
- itemCount = Global.getProject().getTotalFunctionEntryCount();
- }
- return itemCount;
+ /**
+ * Get all web function entry data from DB.
+ *
+ * @return list of rows, where row is list of objects,
+ * <code>null</code> if there is no required data in the DB
+ */
+ private List<List<Object>> getWebFunctionEntryData() {
+ return CallTraceDataManager.getInstance().getWebFunctionEntryTable().selectAllObjectData();
}
- @Override
- protected String getSelectQueryOption() {
- StringBuffer query = new StringBuffer();
- int selectedPid = Toolbar.INSTANCE.getSelectedPid();
- if (selectedPid != 0) {
- query.append("pid =" + selectedPid);//$NON-NLS-1$
- }
- /*
- * ToDo need to revision query or windowing logic of windowing table
- */
-// query.append(" order by " + WebFunctionEntryDBTable.COLUMN.START_TIME.getName());
- return query.toString();
- }
+ /**
+ * Select table items falling within specified time interval.
+ *
+ * @param selectionStartTime start of interval
+ * @param selectionEndTime end of interval
+ */
+ public void setSelectionByTime(final long selectionStartTime, final long selectionEndTime) {
+ setSelectionByPredicate(new Predicate<GridItem>() {
+ @Override
+ public boolean evaluate(GridItem item) {
+ DATableDataFormat gridData = (DATableDataFormat) item.getData();
+ if (gridData == null)
+ return false;
- @Override
- protected String getSelectQueryCountOption() {
- StringBuffer query = new StringBuffer();
- int selectedPid = Toolbar.INSTANCE.getSelectedPid();
- if (selectedPid != 0) {
- query.append("pid =" + selectedPid);//$NON-NLS-1$
- }
- return query.toString();
- }
-
- @Override
- protected String getTimeColumnName() {
- return WebFunctionEntryDBTable.COLUMN.START_TIME.getName();
+ long time = (Long) gridData.getData().get(WebFunctionEntryDBTable.COLUMN.START_TIME.index);
+ return selectionStartTime <= time && time <= selectionEndTime;
+ }
+ });
}
}
\ No newline at end of file
// for range analysis
private static final String SELECT_COLUMN =
- COLUMN.SEQUENCE_NUMBER.getName() + CommonConstants.COMMA +
- COLUMN.PID.getName() + CommonConstants.COMMA +
- COLUMN.TID.getName() + CommonConstants.COMMA +
- COLUMN.FUNCTION_LINE_NUMBER.getName() + CommonConstants.COMMA +
- COLUMN.FUNCTION_NAME.getName() + CommonConstants.COMMA +
- COLUMN.FUNCTION_URL.getName() + CommonConstants.COMMA +
- COLUMN.START_TIME.getName();
+ COLUMN.SEQUENCE_NUMBER.name + CommonConstants.COMMA +
+ COLUMN.PID.name + CommonConstants.COMMA +
+ COLUMN.TID.name + CommonConstants.COMMA +
+ COLUMN.FUNCTION_LINE_NUMBER.name + CommonConstants.COMMA +
+ COLUMN.FUNCTION_NAME.name + CommonConstants.COMMA +
+ COLUMN.FUNCTION_URL.name + CommonConstants.COMMA +
+ COLUMN.START_TIME.name;
public static final String SELECT_QUERY =
"select " + SELECT_COLUMN + " from " + TABLE_NAME +
FUNCTION_URL(5, "FUNCTION_URL"),
START_TIME(6, DBConstants.DBCOLUMN_START_TIME);
- private final int index;
- private final String name;
+ public final int index;
+ public final String name;
COLUMN(int index, String name) {
this.index = index;
this.name = name;
}
-
- public int getIndex() {
- return index;
- }
-
- public String getName() {
- return name;
- }
}
public WebFunctionEntryDBTable() {
// for range analysis
private static final String SELECT_COLUMN =
COLUMN.EXIT_SEQUENCE_NUMBER.getName() + CommonConstants.COMMA +
- WebFunctionEntryDBTable.COLUMN.PID.getName() + CommonConstants.COMMA +
- WebFunctionEntryDBTable.COLUMN.TID.getName() + CommonConstants.COMMA +
- WebFunctionEntryDBTable.COLUMN.FUNCTION_LINE_NUMBER.getName() + CommonConstants.COMMA +
- WebFunctionEntryDBTable.COLUMN.FUNCTION_NAME.getName() + CommonConstants.COMMA +
- WebFunctionEntryDBTable.COLUMN.FUNCTION_URL.getName() + CommonConstants.COMMA +
+ WebFunctionEntryDBTable.COLUMN.PID.name + CommonConstants.COMMA +
+ WebFunctionEntryDBTable.COLUMN.TID.name + CommonConstants.COMMA +
+ WebFunctionEntryDBTable.COLUMN.FUNCTION_LINE_NUMBER.name + CommonConstants.COMMA +
+ WebFunctionEntryDBTable.COLUMN.FUNCTION_NAME.name + CommonConstants.COMMA +
+ WebFunctionEntryDBTable.COLUMN.FUNCTION_URL.name + CommonConstants.COMMA +
COLUMN.END_TIME.getName();
public static final String SELECT_QUERY =
"select " + SELECT_COLUMN +
" from " + TABLE_NAME + CommonConstants.COMMA + WebFunctionEntryDBTable.TABLE_NAME +
" where " + COLUMN.ENTRY_SEQUENCE_NUMBER.getName() + CommonConstants.EQUAL +
- WebFunctionEntryDBTable.COLUMN.SEQUENCE_NUMBER.getName() +
+ WebFunctionEntryDBTable.COLUMN.SEQUENCE_NUMBER.name +
" and " + COLUMN.END_TIME.name + " between %s and %s";
public enum COLUMN {
import java.util.Map;
import org.eclipse.swt.widgets.Display;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
private int rootPID;
private static final int totalAllocSeriesID = -100;
- private static final int appAllocSeriesID = -10;
public HeapChart(String pageID) {
super(pageID);
DAChartSeries targetAllocationSeries = new DAChartSeries(
TimelineChartLabels.HEAP_CHART_SERIES_NAME_APP_ALLOCATION,
DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_HEAP_USER);
- chartSeriesMap.put(appAllocSeriesID, targetAllocationSeries);
+ chartSeriesMap.put(AnalyzerConstants.MAIN_EXECUTABLE_ID, targetAllocationSeries);
return chartSeriesMap;
}
// located
// at first
// index.
- DAChartSeries appAllocSeries = seriesMap.get(appAllocSeriesID);
+ DAChartSeries appAllocSeries = seriesMap.get(AnalyzerConstants.MAIN_EXECUTABLE_ID);
appAllocSeries.addSeriesItem(new DAChartSeriesItem(time, targetAlloc, Formatter
.toByteFormat(targetAlloc)));
librarySequenceList.add(binaryID);
}
}
- chart.addSeries(seriesMap.get(appAllocSeriesID));
+ chart.addSeries(seriesMap.get(AnalyzerConstants.MAIN_EXECUTABLE_ID));
}
@Override
}
private void loadSavedChartList() {
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
List<String> chartNameList = target.getAvailableChartList();
int size = chartNameList.size();
newChartList.add(customChart);
newCustomChart = true;
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
List<String> list = new ArrayList<String>();
for (int i = 0; i < chartList.size(); i++) {
list.add(chartList.get(i).getChartName());
@Override
public void makeChartSeries(long startTime, long endTime) {
- TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTargetOrSelected();
Set<String> targetChartList = SettingDataManager.INSTANCE.getSelectedChartSet(target
.getTargetName());
import java.util.List;
import java.util.Map;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.database.DBInserter;
private static final int MEM_API_TYPE_ALLOC = 0;
private static final int MEM_API_TYPE_FREE = 1;
private static final int MEM_USER = 2;
- private static final int appAllocSeriesID = -10;
// Map<PID, target Allocation Byte>
private Map<Integer, Long> allocByteMap = new HashMap<Integer, Long>();
*/
List<Object> binaryIDList = new ArrayList<Object>();
List<Object> allocByteList = new ArrayList<Object>();
- binaryIDList.add(appAllocSeriesID);
+ binaryIDList.add(AnalyzerConstants.MAIN_EXECUTABLE_ID);
if (allocByteMap.get(process.getPid()) == null) {
allocByteList.add(new Long(0));
} else {
private void drawMainContents() {
Composite contents = new Composite(mainContentsComp, SWT.NONE);
FormData form = new FormData();
- form.top = new FormAttachment(0, 15);
+ form.top = new FormAttachment(0, 22);
form.left = new FormAttachment(0, 20);
form.bottom = new FormAttachment(100, -15);
form.width = 104;
Composite valuecontents = new Composite(mainContentsComp, SWT.NONE);
form = new FormData();
- form.top = new FormAttachment(0, 15);
+ form.top = new FormAttachment(0, 22);
form.left = new FormAttachment(contents, 47);
- form.bottom = new FormAttachment(100, -15);
+ form.bottom = new FormAttachment(100, -17);
form.width = 200;
valuecontents.setLayoutData(form);
valuecontents.setBackground(ColorResources.DIALOG_CONTENT_BACKGROUND);
daversion.setForeground(ColorResources.DEFAULT_FONT_COLOR);
daversion.setText(AnalyzerLabels.ABOUT_DIALOG_DA_VERSION);
+ ((FormData)contents.getLayoutData()).top = new FormAttachment(0, 17);
Label buildtime = new Label(contents, SWT.LEFT);
buildtime.setFont(FontResources.DIALOG_CONTENTS_BOLD_FONT);
buildtime.setBackground(ColorResources.DIALOG_CONTENT_BACKGROUND);
tizensite.setForeground(ColorResources.DEFAULT_FONT_COLOR);
tizensite.setText(AnalyzerLabels.ABOUT_DIALOG_TIZEN_SITE);
+ ((FormData)contents.getLayoutData()).bottom = new FormAttachment(100, -22);
Label releasenote = new Label(contents, SWT.LEFT);
releasenote.setFont(FontResources.DIALOG_CONTENTS_BOLD_FONT);
releasenote.setBackground(ColorResources.DIALOG_CONTENT_BACKGROUND);
daversionvalue.setForeground(ColorResources.DEFAULT_FONT_COLOR);
daversionvalue.setText(daVersionInfo);
+ ((FormData)valuecontents.getLayoutData()).top = new FormAttachment(0, 17);
Label buildtimevalue = new Label(valuecontents, SWT.LEFT);
buildtimevalue.setFont(FontResources.DIALOG_CONTENTS_NORMAL_FONT);
buildtimevalue.setBackground(ColorResources.DIALOG_CONTENT_BACKGROUND);
}
});
+ ((FormData)valuecontents.getLayoutData()).bottom = new FormAttachment(100, -22);
Link releasenotevalue = new Link(valuecontents, SWT.LEFT);
releasenotevalue.setFont(FontResources.DIALOG_CONTENTS_NORMAL_FONT);
releasenotevalue.setBackground(ColorResources.DIALOG_CONTENT_BACKGROUND);
private void drawButtons() {
Button okButton = new Button(buttonContentsComp, SWT.NONE);
FormData buttonData = new FormData();
- buttonData.top = new FormAttachment(0, 15);
- buttonData.right = new FormAttachment(100, -15);
- buttonData.width = 100;
- buttonData.height = 30;
+ buttonData.top = new FormAttachment(0, 18);
+ buttonData.right = new FormAttachment(100, -20);
+ buttonData.width = 86;
+ buttonData.height = 24;
okButton.setLayoutData(buttonData);
okButton.setFont(FontResources.DIALOG_BUTTON_FONT);
okButton.setText(WidgetLabels.CLOSE);
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.events.VerifyEvent;
+import org.eclipse.swt.events.VerifyListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.tizen.dynamicanalyzer.nl.WidgetLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
+import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.widgets.animation.DAAnimationIcon;
import org.tizen.dynamicanalyzer.widgets.da.base.DAMessageBox;
import org.tizen.dynamicanalyzer.widgets.da.base.DATextBox;
data.width = EDITBOX_WIDTH;
ipTextbox.setLayoutData(data);
ipTextbox.setBackground(ColorResources.WHITE);
- ipTextbox.getControl().addKeyListener(ipTextboxListener);
+ ipTextbox.getControl().addKeyListener(textboxListener);
+ ipTextbox.getControl().addVerifyListener(new TextBoxVerifyListener("0123456789."));
portTextbox = new DATextBox(mainContentsComp, SWT.SINGLE);
data = new FormData();
data.width = EDITBOX_WIDTH;
portTextbox.setLayoutData(data);
portTextbox.setBackground(ColorResources.WHITE);
- portTextbox.getControl().addKeyListener(portTextboxListener);
+ portTextbox.getControl().addKeyListener(textboxListener);
+ portTextbox.getControl().addVerifyListener(new TextBoxVerifyListener("0123456789"));
}
private void drawButtons() {
buttonData.width = 100;
buttonData.height = 30;
cancelButton.setLayoutData(buttonData);
- ;
cancelButton.setText(WidgetLabels.CANCEL);
cancelButton.addSelectionListener(cancelButtonListener);
}
};
- private KeyListener ipTextboxListener = new KeyListener() {
+ /**
+ * {@link VerifyListener} for textboxes.
+ */
+ private class TextBoxVerifyListener implements VerifyListener {
- @Override
- public void keyReleased(KeyEvent e) {
- if (!checkValidIP(ipTextbox.getText())) {
- connectButton.setEnabled(false);
- } else {
- connectButton.setEnabled(true);
- }
+ private String allowedChars = "";
- connectButton.redraw();
+ /**
+ * Creates new instance with given allowed characters for input.
+ *
+ * @param allowedChars allowed characters for input
+ */
+ public TextBoxVerifyListener(String allowedChars) {
+ this.allowedChars = allowedChars;
}
@Override
- public void keyPressed(KeyEvent e) {
-
+ public void verifyText(VerifyEvent e) {
+ for (int i = 0; i < e.text.length(); i++) {
+ char ch = e.text.charAt(i);
+ if (allowedChars.indexOf(ch) < 0) {
+ e.doit = false;
+ return;
+ }
+ }
}
- };
- private KeyListener portTextboxListener = new KeyListener() {
+ }
+
+ /**
+ * Validates textboxes and sets 'Ok' button as enabled if input is valid and
+ * disabled otherwise.
+ */
+ private KeyListener textboxListener = new KeyListener() {
@Override
public void keyReleased(KeyEvent e) {
- if (!checkValidPort(portTextbox.getText())) {
- connectButton.setEnabled(false);
- } else {
- connectButton.setEnabled(true);
- }
-
+ boolean valid = checkValidPort(portTextbox.getText()) && checkValidIP(ipTextbox.getText());
+ connectButton.setEnabled(valid);
connectButton.redraw();
}
}
};
+ /**
+ * Validate IP textbox text.
+ *
+ * @param ipaddr text from IP textbox
+ * @return {@code true} if text is valid
+ */
private boolean checkValidIP(String ipaddr) {
String[] splitstr = ipaddr.split("\\.");
if (splitstr == null || splitstr.length != CommonConstants.IPv4_OCTET_NUMBER) {
}
for (int i = 0; i < CommonConstants.IPv4_OCTET_NUMBER; i++) {
- int classnum = Integer.parseInt(splitstr[i]);
- if (classnum < 0 || classnum > CommonConstants.MAX_OCTET_NUMBER) {
+ if (!CommonUtil.isNumeric(splitstr[i]))
+ return false;
+
+ try {
+ int classnum = Integer.parseInt(splitstr[i]);
+ if (classnum < 0 || classnum > CommonConstants.MAX_OCTET_NUMBER) {
+ return false;
+ }
+ } catch (NumberFormatException e) {
return false;
}
}
return true;
}
+ /**
+ * Validate port textbox text.
+ *
+ * @param port text from port textbox
+ * @return {@code true} if text is valid
+ */
private boolean checkValidPort(String port) {
if (port.isEmpty()) {
return true;
+ } else if (!CommonUtil.isNumeric(port)) {
+ return false;
}
- int portnum = Integer.parseInt(port);
+ int portnum = -1;
- if (portnum < CommonConstants.MIN_PORT_NUMBER || portnum > CommonConstants.MAX_PORT_NUMBER) {
+ try {
+ portnum = Integer.parseInt(port);
+ } catch (NumberFormatException e) {
return false;
- } else {
- return true;
}
+
+ return portnum >= CommonConstants.MIN_PORT_NUMBER && portnum <= CommonConstants.MAX_PORT_NUMBER;
}
public String getAddress() {
pixelSize += (gc.getCharWidth(ch));\r
}\r
if(pixelSize > srcWidth){\r
- cutText = srcText.substring(0, cutIndex - 2);\r
- cutText = cutText + "...";\r
+ // FIXME: temporary workaround check in order to prevent\r
+ // throwing the IndexOutOfBoundsException\r
+ if (cutIndex >= 2 && cutIndex <= srcText.length() + 2) {\r
+ cutText = srcText.substring(0, cutIndex - 2);\r
+ cutText = cutText + "...";\r
+ }\r
return cutText;\r
}\r
cutIndex++;\r
DAResult.ErrorCode.ERR_DEVICE_TARGET_MISMATCH
.getErrorMessage()
+ "\nDevice type: "
- + SettingDataManager.INSTANCE.getConnected().getTargetName()
+ + SettingDataManager.INSTANCE.getConnectedTargetOrNull().getTargetName()
+ "\nSelected target: "
+ SettingDataManager.INSTANCE.getSelectedTarget());
Logger.info(DAResult.ErrorCode.ERR_DEVICE_TARGET_MISMATCH
}
updateNewComboThread();
-
- synchronized(oldPkgList){
- composeAppCombo(oldPkgList);
- }
+ // New applications may be installed, so list should be updated.
+ composeAppCombo(getAppListFromTarget());
ShowAppComboTitle();
*/
package org.tizen.dynamicanalyzer.ui.toolbar.setting;
-import java.util.LinkedList;
-
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.tizen.dynamicanalyzer.nl.WidgetLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
-import org.tizen.dynamicanalyzer.setting.FlatFeature;
import org.tizen.dynamicanalyzer.setting.SettingDataManager;
import org.tizen.dynamicanalyzer.shortcut.ShortCutManager;
import org.tizen.dynamicanalyzer.widgets.da.base.DAMessageBox;
final public int SELECTED_WIDTH = 285; // SelectedList have to draw line
final public int SELECTED_HEIGHT = 489 + TITLE_HEIGHT;
- LinkedList<FlatFeature> orderedFeatureList = new LinkedList<FlatFeature>();
-
public FlatFeatureDialog(Shell parentShell) {
super(parentShell);
}
import java.util.ArrayList;
import java.util.Collections;
-import java.util.HashSet;
import java.util.List;
import org.eclipse.swt.SWT;
DACustomFeatureToggleButton toggleButton = (DACustomFeatureToggleButton) event.widget;
TargetData target = SettingDataManager.INSTANCE.getTarget(null);
if (!toggleButton.isToggled()) {
- featureDialog.orderedFeatureList.remove(FlatFeature.getFlatFeature(toggleButton.getText()));
target.removeSelectedFlatFeature(toggleButton.getText());
toggleButton.getParent().setBackground(ColorResources.FEATURE_FEATURELISTCOMP_NORMAL_BACKGROUND);
toggleButton.getTooltipButton().setBackground(ColorResources.FEATURE_FEATURELISTCOMP_NORMAL_BACKGROUND);
}
else {
- featureDialog.orderedFeatureList.add(0, FlatFeature.getFlatFeature(toggleButton.getText()));
target.addSelectedFlatFeature(toggleButton.getText());
toggleButton.getParent().setBackground(ColorResources.FEATURE_FEATURELISTCOMP_SELECT_BACKGROUND);
toggleButton.getTooltipButton().setBackground(ColorResources.FEATURE_FEATURELISTCOMP_SELECT_BACKGROUND);
}
- featureDialog.getSelectedFeaturePage().createSelectedFeatureComposite(featureDialog.orderedFeatureList);
+ featureDialog.getSelectedFeaturePage().createSelectedFeatureComposite();
}
};
toggledata.height = FEATURELIST_BODY_ITEM_HEIGHT
* target.getAvailableFlatFeatures().size();
toggle.setLayoutData(toggledata);
- target.setSelectedFlatFeatures(new HashSet<FlatFeature>());
} else {
List<FlatFeature> features = new ArrayList<FlatFeature>();
features.addAll(target.getAvailableFlatFeatures());
Collections.sort(features, FlatFeature.getIndexComparator());
- if ((featureDialog.orderedFeatureList.isEmpty())
- && (!target.getSelectedFlatFeatures().isEmpty()))
- featureDialog.orderedFeatureList.addAll(target
- .getSelectedFlatFeatures());
Logger.debug("Available FlatFeature list: " + features);
featuretoggleGroup = new DACustomMultiToggleButtonGroup();
*/
package org.tizen.dynamicanalyzer.ui.toolbar.setting;
-import java.util.Collections;
-import java.util.LinkedList;
-
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.PaintEvent;
NOITEM_UPPER_MARGIN = (BODY_HEIGHT-TITLE_FONT_SIZE)/2;
NOITEM_LEFT_MARGIN = 15; // TODO: Replace '15' with string length
- createSelectedFeatureComposite(featureDialog.orderedFeatureList);
+ createSelectedFeatureComposite();
}
private void initSelectedFeatureCompositeWidget() {
DACustomToggleButton toggleButton = (DACustomToggleButton) event.widget;
TargetData target = SettingDataManager.INSTANCE.getTarget(null);
target.removeSelectedFlatFeature(toggleButton.getText());
- featureDialog.orderedFeatureList.remove(FlatFeature.getFlatFeature(toggleButton.getText()));
featureDialog.getFeatureListPage().featureToggleUnselect(toggleButton.getText());
- createSelectedFeatureComposite(featureDialog.orderedFeatureList);
+ createSelectedFeatureComposite();
}
};
*
* @param orderedFeatureList List, contains selected FlatFeatures in selection order.
*/
- public void createSelectedFeatureComposite(
- LinkedList<FlatFeature> orderedFeatureList) {
+ public void createSelectedFeatureComposite() {
initSelectedFeatureCompositeWidget();
// label
});
// listing selected feature list
- if (orderedFeatureList == null) {
- orderedFeatureList = new LinkedList<FlatFeature>();
- }
- if (orderedFeatureList.isEmpty()) {
- TargetData target = SettingDataManager.INSTANCE.getTarget(null);
- if (!target.getSelectedFlatFeatures().isEmpty()) {
- orderedFeatureList.addAll(target.getSelectedFlatFeatures());
- Collections.sort(orderedFeatureList, FlatFeature.getIndexComparator());
- }
- }
- Logger.debug(orderedFeatureList);
+ TargetData target = SettingDataManager.INSTANCE.getTarget(null);
+ Logger.debug(target.getSelectedFlatFeatures());
- if (orderedFeatureList.size() > 0)
+ if (target.getSelectedFlatFeatures().size() > 0)
featureDialog.getOKButton().setEnabled(true);
else {
featureDialog.getOKButton().setEnabled(false);
int topPosition = BODY_TOP_MARGIN;
int leftPosition = ITEM_LEFT;
- for (FlatFeature feature : orderedFeatureList) {
+ for (FlatFeature feature : target.getSelectedFlatFeatures()) {
// image
selectedIcon = new Label(selectedInputComp, SWT.TRANSPARENT);
selectedIcon.setImage(feature.getSmallImage());
// update feature list, selected feature pages
featureDialog.getFeatureListPage().createFeatureListComposite();
- featureDialog.getSelectedFeaturePage().createSelectedFeatureComposite(featureDialog.orderedFeatureList);
+ featureDialog.getSelectedFeaturePage().createSelectedFeatureComposite();
}
}
};
// ToogleButtonGroup
Map<String, TargetData> targetList = SettingDataManager.INSTANCE.getTargetListMap();
- String selectedTarget = SettingDataManager.INSTANCE.getConnectedTarget().getTargetName();
+ String selectedTarget = SettingDataManager.INSTANCE.getConnectedTargetOrSelected().getTargetName();
SettingDataManager.INSTANCE.setSelectedTarget(selectedTarget);
DACustomFeatureToggleButtonGroup targetGroup = new DACustomFeatureToggleButtonGroup();
// ToogleButtonGroup
Map<String, TargetData> targetList = SettingDataManager.INSTANCE.getTargetListMap();
- String selectedTarget = SettingDataManager.INSTANCE.getConnectedTarget().getTargetName();
+ String selectedTarget = SettingDataManager.INSTANCE.getConnectedTargetOrSelected().getTargetName();
SettingDataManager.INSTANCE.setSelectedTarget(selectedTarget);
DACustomToggleButtonGroup targetGroup = new DACustomToggleButtonGroup();
Point imagePoint = new Point(18, 8);
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Listener;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.common.Global;
public UIControlListTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
- table.addListener(SWT.Expand, new Listener() {
-
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, true);
- }
- });
-
- table.addListener(SWT.Collapse, new Listener() {
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, false);
- }
- });
table.addSelectionListener(new SelectionListener() {
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Listener;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
comparator.setColumn(2);
comparator.reverseDirection();
- table.addListener(SWT.Expand, new Listener() {
-
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, true);
- }
- });
-
- table.addListener(SWT.Collapse, new Listener() {
- @Override
- public void handleEvent(Event event) {
- GridItem item = (GridItem) event.item;
- setExpand(item, false);
- }
- });
-
table.addSelectionListener(new SelectionListener() {
@Override
private static final int WIDTH = 430;
private static final int HEIGHT = 230 - 7; // Should remove 7 pixel on titlebar area at MAC
private static final int HORIZONTAL_SPACING = 15;
- private static final int VERTICAL_SPACING = 15;
- private static final int HEIGHT_MARGIN = 20;
private static final int WIDTH_MARGIN = 26;
private static final int BUTTON_HEIGHT = 30;
private static final int CONTENT_COMP_HEIGHT = 138;
Label descriptionLabel = new Label(contentComp, SWT.TRANSPARENT);
data = new FormData();
- data.top = new FormAttachment(0, HEIGHT_MARGIN);
+ data.top = new FormAttachment(25, -descriptionLabel.computeSize(SWT.DEFAULT, SWT.DEFAULT).y / 2);
data.left = new FormAttachment(0, WIDTH_MARGIN);
descriptionLabel.setLayoutData(data);
descriptionLabel.setBackground(ColorResources.DIALOG_CONTENT_BACKGROUND);
textBox = new Text(contentComp, SWT.SINGLE | SWT.BORDER);
data = new FormData();
- data.top = new FormAttachment(descriptionLabel, VERTICAL_SPACING);
+ data.top = new FormAttachment(50, -textBox.computeSize(SWT.DEFAULT, SWT.DEFAULT).y / 2);
data.left = new FormAttachment(0, WIDTH_MARGIN);
- // data.height = TEXTBOX_HEIGHT;
data.right = new FormAttachment(100, -WIDTH_MARGIN);
textBox.setLayoutData(data);
textBox.setFont(new Font(textBox.getDisplay(), "Arial", 10, SWT.NORMAL));
textBox.addKeyListener(keyListener);
- FormAttachment top = new FormAttachment(textBox, VERTICAL_SPACING);
+ FormAttachment top = new FormAttachment(75, -descriptionLabel.computeSize(SWT.DEFAULT, SWT.DEFAULT).y / 2);
Label optionLabel = new Label(contentComp, SWT.TRANSPARENT);
data = new FormData();
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.ui.common.PopupAnalysisMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.page.BaseView;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.widgets.DAGrid;
import org.tizen.dynamicanalyzer.ui.widgets.FilterDialog;
import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenuListener;
public abstract class DATableComposite extends Composite {
+ /**
+ * Predicate interface for evaluating some condition on arbitrary object.
+ */
+ public interface Predicate<T> {
+ /**
+ * Method should answer whether predicate is true for object.
+ *
+ * @param obj object to evaluate
+ * @return <code>true</code> if predicate for object is true,
+ * <code>false</code> otherwise
+ */
+ public boolean evaluate(T obj);
+ }
+
protected static final int START_TIME = 0;
protected static final int END_TIME = 1;
protected List<FilterProperty> filterPropertyList;
protected Grid table;
+
+ /**
+ * Contains filtered list of table items.
+ */
+ protected List<TableInput> filteredTable = new ArrayList<TableInput>();
+ /**
+ * Contains list of table items available for current moment.
+ */
+ protected List<TableInput> tableClone = new ArrayList<TableInput>();
+ /**
+ * Indicates whether table is filtered.
+ */
+ protected boolean isFilter = false;
+
+ private static String POPUP_FILTER_BY = "Filter by selected ";
+ private static String POPUP_SHOW_ALL_ITEMS = "Show all items";
+
protected List<Integer> selectionIndex;
protected HashMap<Long, Long> selection;
protected TableTooltipListener tableListener;
return selectionIndex;
}
+ /**
+ * Select all items using specified predicate.
+ * Predicate will be called for every grid item (row) and
+ * it should return <code>true</code> if grid item should be selected.
+ *
+ * @param select selection predicate
+ */
+ public void setSelectionByPredicate(Predicate<GridItem> select) {
+ List<GridItem> selectionList = new ArrayList<>();
+ GridItem[] items = table.getItems();
+
+ int lastSelectedIndex = 0;
+
+ for (int i = 0; i < items.length; i++) {
+ GridItem item = items[i];
+ if (select.evaluate(item)) {
+ selectionList.add(item);
+ lastSelectedIndex = i;
+ }
+ }
+
+ table.setSelection(selectionList.toArray(new GridItem[0]));
+
+ if (lastSelectedIndex > 0) {
+ table.getVerticalBar().setSelection(lastSelectedIndex - 1);
+ } else {
+ table.getVerticalBar().setSelection(0);
+ }
+ }
+
public void clear() {
table.removeAll();
getSelectionIndex().clear();
return queries;
}
+
+ /**
+ * Add filters to all columns except "Time" and "Seq" columns. Also adds
+ * "show all" item that reverts all filter actions.
+ */
+ protected void initFilterPopupMenu() {
+ popupMenu = new DAPopupMenu(table);
+ popupMenu.setFont(FontResources.CONTEXT_MENU_ITEM_FONT);
+
+ for (int i = 0; i < table.getColumns().length; i++) {
+ final int index = i;
+ GridColumn column = table.getColumn(i);
+ if (column.getText().toLowerCase().contains("seq")
+ || column.getText().toLowerCase().contains("time")
+ || column.getText().toLowerCase()
+ .contains("streaming is not supported")
+ || column.getText().equals("")) {
+ continue;
+ }
+
+ DAPopupMenuItem filterByItem = new DAPopupMenuItem(popupMenu);
+ filterByItem.setText(POPUP_FILTER_BY + column.getText());
+ filterByItem.addListener(new DAPopupMenuListener() {
+ @Override
+ public void widgetSelected(DAPopupMenuItem menuItem) {
+ GridItem item = table.getItem(new Point(mousePoint.x,
+ mousePoint.y));
+ if (null == item) {
+ return;
+ }
+
+ String startData = item.getText(index);
+ filterTable(startData, index);
+ }
+ });
+ }
+
+ DAPopupMenuItem showAllItem = new DAPopupMenuItem(popupMenu);
+ showAllItem.setText(POPUP_SHOW_ALL_ITEMS);
+ showAllItem.addListener(new DAPopupMenuListener() {
+ @Override
+ public void widgetSelected(DAPopupMenuItem menuItem) {
+ isFilter = false;
+ table.update();
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ BaseView baseView = (BaseView) WorkbenchUtil
+ .getViewPart(BaseView.ID);
+ baseView.getTopComposite().updateView();
+ }
+ });
+ }
+ });
+ }
+
+ /**
+ * Method to filter table that will hide elements with specified field
+ * differ from specified value.
+ *
+ * @param input field value of specified table item in string representation
+ * @param categoryIndex index of field
+ */
+ private void filterTable(String input, int categoryIndex) {
+
+ filteredTable.clear();
+
+ if (tableClone != null) {
+ for (TableInput table : tableClone) {
+ if (table.getText().get(categoryIndex).equals(input)) {
+ filteredTable.add(table);
+ isFilter = true;
+ }
+ }
+ }
+ table.update();
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ BaseView baseView = (BaseView) WorkbenchUtil
+ .getViewPart(BaseView.ID);
+ baseView.getTopComposite().updateView();
+ }
+ });
+ }
}
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Listener;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.model.TreeInput;
protected HashMap<String, GridItem> gridMap = null;
public DATreeComposite(Composite parent, int style) {
- super(parent, style);
+ this(parent, SWT.NONE, style);
}
public DATreeComposite(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
applyFilterImage();
+
+ table.addListener(SWT.Expand, new Listener() {
+ @Override
+ public void handleEvent(Event event) {
+ GridItem item = (GridItem) event.item;
+ setExpand(item, true);
+ }
+ });
+
+ table.addListener(SWT.Collapse, new Listener() {
+ @Override
+ public void handleEvent(Event event) {
+ GridItem item = (GridItem) event.item;
+ setExpand(item, false);
+ }
+ });
}
protected HashMap<Long, Boolean> getExpandMap() {
+* 2.3.17
+- Memory Map table now shows maps for different processes separately
+- Implement filter popup menu for Persistent Allocations table
+- Update screenshot feature selection in CLI
+- Update according to common-eplugin SdbHelper API changes
+- Fix About dialog according to GUI guide
+- Fix port accuring for CLI communication process
+- Fix application selection combobox to be up to date
+- Fix the list of selected features not updated on target change (regression in DA 2.3.16)
+- Fix Persistent Memory charts for main executable (regression in DA 2.3.16)
+- Fix Persistent Memory charts to be updated immediately on switch on/off (regression in DA 2.3.16)
+- Fix 13 FindBugs warnings
+- Modify architecture of CallTraceView class
+- Replace pixel top offsets in SearchDialog with ratio offsets
+- Refactor SettingDataManager class
+- Fix JIRA defects:
+ SPTSDKUX-1909: Startup info not shown when selecting UIHV features
+ SPTSDKUX-2159: In Dynamic analyzer while typing any text in remote device window, GUI gets disturbed.
+== Maria Guseva <m.guseva@samsung.com> October 05, 2016
* 2.3.16
- Improve Memory Statistics table and Heap Allocation charts UX:
- change data model of Statistics table to tree,
Source:dynamic-analyzer
-Version:2.3.16
+Version:2.3.17
Maintainer:Gihun Chang <gihun.chang@samsung.com>, WooJin Jung <woojin2.jung@samsung.com>, Jaewon Lim <jaewon81.lim@samsung.com>, Seokgil Kang <seokgil.kang@samsung.com>
Package:dynamic-analyzer-product
echo "Usage: ./prepare_dependencies.sh /absolute/path/to/eclipse /absolute/path/to/common-eplugin"
}
+__checkDir() {
+ if [[ ! -d ${1} ]]; then
+ echo "Error: specified path is not an existing directory - ${1}"
+ __printHelp
+ exit 100
+ fi
+}
+
if [[ -z ${1} ]]; then
__printHelp
exit 0
fi
-if [[ ! -d ${1} || ! -d ${2} ]]; then
- echo "Error: specified paths are not existing directories"
- __printHelp
- exit 1
-fi
+__checkDir ${1}
+__checkDir ${2}
if [[ -z ${SRCDIR} ]]; then
SRCDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
projects / sdk / tools / dynamic-analyzer.git / commitdiff