import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Rectangle;
-import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
package org.tizen.dynamicanalyzer.widgets.da.view;
-import java.awt.Button;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
package org.tizen.dynamicanalyzer.callback;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.HashMap;
public class ExecutionCallbackManager {
private static Map<String, List<IExecutionCallback>> callbackMap = new HashMap<String, List<IExecutionCallback>>();
import java.util.List;
import org.tizen.common.core.application.InstallPathConfig;
-import org.tizen.dynamicanalyzer.util.CommonUtil;
public class InternalLogger {
public enum testState {
import org.eclipse.swt.widgets.Canvas;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButton;
-import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonRenderer;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonAttribute;
+import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonRenderer;
public class DACustomToggleButtonRenderer extends DACustomButtonRenderer {
@Override
package org.tizen.dynamicanalyzer.widgets.chartBoard;
import java.util.ArrayList;
-import java.util.List;
-import java.util.Comparator;
import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Canvas;
-
import org.tizen.dynamicanalyzer.widgets.helper.ColorResources;
import org.tizen.dynamicanalyzer.widgets.scale.DAScaleAttribute;
import org.tizen.dynamicanalyzer.widgets.scale.DAScaleDefaultRenderer;
import java.io.File;
import java.io.FilenameFilter;
+
import org.tizen.common.core.application.InstallPathConfig;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.nl.WorkbenchLabels;
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.util.FileUtil;
+import org.tizen.dynamicanalyzer.util.InternalLogger;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.da.base.DADialog;
-import org.tizen.dynamicanalyzer.util.InternalLogger;
public class Application implements IApplication {
private static final String LOG_PREFIX = "da_log_";
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;
-
import org.tizen.dynamicanalyzer.callback.ExecutionCallbackManager;
public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
+
import org.tizen.dynamicanalyzer.common.path.PathConstants;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
public class AnalyzerManager {
- private static Project project = null;
private static boolean isRunning = false;
private static boolean isLogParsingComplete = false;
}
public static void clear() {
+ Project project = Global.getProject();
if (null != project) {
if (!project.isValid()) {
String sourcePath = project.getSavePath();
}
}
project.dispose();
- project = null;
+ Global.setProject(null);
}
imageSet = null;
long imgTime = Long.parseLong(imageList.get(i).getTime());
long time = Long.parseLong(timeStr);
if (imgTime <= time) {
- path = AnalyzerManager.getProject().getSavePath() + File.separator
+ path = Global.getProject().getSavePath() + File.separator
+ AnalyzerConstants.IMAGE_FOLDER_NAME + File.separator
+ imageList.get(i).getSeq() + CommonConstants.EXTENSION_PNG_IMAGE;
} else {
return -1;
}
- public static void setProject(Project p) {
- project = p;
- }
-
- public static void setProjectNoRegist(Project p) {
- project = p;
- }
-
- public static Project getProject() {
- return project;
- }
-
public static NewLeakDetector getNewLeakDetector() {
return newLeakDetector;
}
}
public static BaseCallstackManager getCallstackManager() {
- Project curProject = getProject();
+ Project curProject = Global.getProject();
if (curProject != null) {
// TODO : protocol version definition
String pver = curProject.getProtocolVersion();
package org.tizen.dynamicanalyzer.common;\r
\r
import java.io.File;\r
+\r
import org.eclipse.ui.IWorkbench;\r
import org.eclipse.ui.IWorkbenchListener;\r
import org.eclipse.ui.IWorkbenchWindow;\r
import java.util.List;
import org.eclipse.cdt.utils.elf.Elf;
+import org.eclipse.cdt.utils.elf.Elf.ELFhdr;
import org.eclipse.cdt.utils.elf.Elf.PHdr;
import org.eclipse.cdt.utils.elf.Elf.Symbol;
-import org.eclipse.cdt.utils.elf.Elf.ELFhdr;
import org.tizen.dynamicanalyzer.model.AddrSymbolPair;
public class ElfSymbolExtractor {
return currentDevice;
}
- public static Project getCurrentProject() {
- return currentProject;
- }
-
public static void setCurrentDeviceInfo(DeviceInfo device) {
currentDevice = device;
}
- public static void setCurrentProject(Project project) {
- currentProject = project;
- }
-
public static PackageInfo getCurrentApplication() {
return currentApplication;
}
return currentConfiguration;
}
- public static void setCurrentConfiguration(
- RunTimeConfiguration currentConfig) {
+ public static void setCurrentConfiguration(RunTimeConfiguration currentConfig) {
currentConfiguration = currentConfig;
}
+
+ public static void setProject(Project p) {
+ currentProject = p;
+ }
+
+ public static Project getProject() {
+ return currentProject;
+ }
}
String functionName = null;
functionId = -1;
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
ProcessInformation process = project.getProcessInformation(pid);
ProcessMemoryMap pmap = process.getProcessMemoryMap(time);
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
+
import org.tizen.dynamicanalyzer.constant.CommonConstants;
public abstract class DBTable implements IPreparedStatement {
import java.io.File;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.sql.SqlManager;
-import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
-import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
public class CommandActionHandler {
public static boolean save(String saveFileName) {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
String sourcePath = project.getSavePath();
String targetPath = PathManager.DA_SAVE_PATH + File.separator
+ saveFileName;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.swt.widgets.Display;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.util.Logger;
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- if (AnalyzerManager.getProject().getSavePath()
+ if (Global.getProject().getSavePath()
.contains(PathManager.DA_TEMP_FOLDER_PATH)) {
ToolbarArea.getInstance().setMainControlEnablement(true);
} else {
import java.io.File;
import java.util.List;
+
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
- project = AnalyzerManager.getProject();
+ project = Global.getProject();
// establish db connection with new path
SqlConnectionManager.closeConnection();
DACustomCombo deviceCombo = ToolbarArea.getInstance()
.getDeviceCombo();
DACustomCombo appCombo = ToolbarArea.getInstance().getAppCombo();
- deviceCombo.setText(AnalyzerManager.getProject().getDevice());
- appCombo.setText(AnalyzerManager.getProject().getAppName());
+ deviceCombo.setText(Global.getProject().getDevice());
+ appCombo.setText(Global.getProject().getAppName());
deviceCombo.setEnabled(true);
appCombo.setEnabled(true);
}
case ProfilingData.TYPE_LIBRARY:
binaryId = (Integer) profilingData
.get(ProfilingDataDBTable.COLUMN.BINARYID.index);
- bInfo = AnalyzerManager.getProject().getDeviceStatusInfo().getBinaryInfo(binaryId);
+ bInfo = Global.getProject().getDeviceStatusInfo().getBinaryInfo(binaryId);
name = bInfo.getTargetBinaryPath();
fupData = new ProfilingData(seq, name, exCount, inCount, callCount,
inElapsedTime, exElapsedTime, profiler);
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.swap.model.data.ReplayData;
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
if (!DACommunicator.isSWAPVersion()) {
- String xmlFileName = AnalyzerManager.getProject().getSavePath() + RECORD_DATA_FILE_NAME;
+ String xmlFileName = Global.getProject().getSavePath() + RECORD_DATA_FILE_NAME;
if (xmlFileName == null || xmlFileName.isEmpty()) {
return FAILED;
} else {
isReplay = true;
- stopTime = AnalyzerManager.getProject().getReplayStopTime();
+ stopTime = Global.getProject().getReplayStopTime();
}
} else {
isReplay = true;
- stopTime = AnalyzerManager.getProject().getReplayStopTime();
- startTime = AnalyzerManager.getProject().getProfilingStartTime();
+ stopTime = Global.getProject().getReplayStopTime();
+ startTime = Global.getProject().getProfilingStartTime();
// make replay event
// on/off , replay start time, count, event objs
import org.eclipse.swt.graphics.Point;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
-import org.tizen.dynamicanalyzer.swap.model.data.FileData;
-import org.tizen.dynamicanalyzer.swap.model.data.GLES20LogData;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
-import org.tizen.dynamicanalyzer.swap.model.data.NetworkData;
-import org.tizen.dynamicanalyzer.swap.model.data.ThreadData;
-import org.tizen.dynamicanalyzer.swap.model.data.UIEventData;
import org.tizen.dynamicanalyzer.ui.file.FilePage;
import org.tizen.dynamicanalyzer.ui.network.NetworkPage;
import org.tizen.dynamicanalyzer.ui.opengl.GLPage;
import org.tizen.dynamicanalyzer.ui.thread.ThreadPage;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
-import org.tizen.dynamicanalyzer.ui.userinterface.UIPage;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.SymbolManager;
import org.tizen.dynamicanalyzer.common.SymbolManager.SourceLine;
import org.tizen.dynamicanalyzer.communicator.IDECommunicator;
filePath = binData.getRpmSourceDir() + sourceLine.getFilePath();
}
} else {
- AppInfo appInfo = AnalyzerManager.getProject().getApplicationInfo();
- BinaryInfo binfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ AppInfo appInfo = Global.getProject().getApplicationInfo();
+ BinaryInfo binfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(appInfo.getExecBinaryPath());
if (binfo.getTargetBinaryPath().equals(libName)
List<Object> calltraceData = tableData.getData();
int binaryId = (Integer) calltraceData
.get(FunctionEntryDBTable.COLUMN.BINARYID.index);
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(binaryId);
libName = binInfo.getTargetBinaryPath();
break;
}
private SourceLine getSourceLine(long addr, int pid, long time) {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
ProcessInformation process = project.getProcessInformation(pid);
ProcessMemoryMap pmap = process.getProcessMemoryMap(time);
path = binInfo.getTempBinaryPath();
}
} else {
- AppInfo appInfo = AnalyzerManager.getProject().getApplicationInfo();
- BinaryInfo binfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ AppInfo appInfo = Global.getProject().getApplicationInfo();
+ BinaryInfo binfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(appInfo.getExecBinaryPath());
if (binInfo.getID() == binfo.getID() // address belongs to c application executable
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.project.FunctionNameManager;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
-import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.dynamicanalyzer.util.ByteUtil;
import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
public class LogParser implements Runnable {
private static Thread logParser = null;
private void logSlicing(List<String> logLumb) {
// String[] slicedLog2 = null;
- // Project project = AnalyzerManager.getProject();
+ // Project project = Global.getProject();
//
// int size = logLumb.size();
// LogPackage logPack = new LogPackage();
// }
//
// // set last log number
- // AnalyzerManager.getProject().setLastLogNum(seqNum, id);
+ // Global.getProject().setLastLogNum(seqNum, id);
// }
//
// updateLog(logPack);
// private void processImage(final String from, String rotate) {
// final String fileName = getImageName(from);
- // final String to = AnalyzerManager.getProject().getSavePath()
+ // final String to = Global.getProject().getSavePath()
// + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
// + File.separator + fileName;
// final int angle = Integer.parseInt(rotate);
// SyncResult res = CommunicatorUtils.pull(from, to);
// if (null != res && res.isOk()) {
// /* image resizing */
- // String smallImagePath = AnalyzerManager.getProject()
+ // String smallImagePath = Global.getProject()
// .getSavePath()
// + File.separator
// + AnalyzerConstants.IMAGE_FOLDER_NAME
// private void setFuncName(UserFunctionData input) {
// boolean isPieBuild = AnalyzerUtil.isPieBuild(input.getPid(),
// input.getTime());
- // String baseAddr = Long.toString(AnalyzerManager.getProject()
+ // String baseAddr = Long.toString(Global.getProject()
// .getBaseAddress(input.getPid(), input.getTime()));
- // // String path = AnalyzerManager.getProject().getBinaryPath();
+ // // String path = Global.getProject().getBinaryPath();
// String path = AnalyzerUtil.getBinarySourcePath(input.getPid(),
// input.getTime());
// String pcAddr = Long.toString(input.getPcAddr());
newLog = new String[2];
// pid
// newLog[0] =
- // Integer.toString(AnalyzerManager.getProject().getPID());
+ // Integer.toString(Global.getProject().getPID());
newLog[0] = null;
newLog[1] = input[LogCenterConstants.PROFILING_LOG_PCADDR_INDEX];
coreCount = i + 1;
}
if (coreCount != 0) {
- AnalyzerManager.getProject().getDeviceStatusInfo().setCpuCount(coreCount);
+ Global.getProject().getDeviceStatusInfo().setCpuCount(coreCount);
}
byte[] cpuFrequency = new byte[temp.length];
System.arraycopy(temp, 0, cpuFrequency, 0, temp.length);
private void processAppInfo(String message) {
// String[] data = message.split(AnalyzerConstants.DATA_PARSING_TOKEN);
//
- // Project project = AnalyzerManager.getProject();
+ // Project project = Global.getProject();
// TargetInfo tInfo = project.getTargetInfo();
// ProcessInfo pInfo = project.getProcessInfo();
//
// private void processImage(final String from) {
// final String fileName = getImageName(from);
- // final String to = AnalyzerManager.getProject().getSavePath()
+ // final String to = Global.getProject().getSavePath()
// + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
// + File.separator + fileName;
//
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.database.DBTable;
import java.util.List;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.util.Logger;
public class FunctionNameManager {
}
public static List<String> getFunctionList() {
- DeviceStatusInfo deviceStatusInfo = AnalyzerManager.getProject().getDeviceStatusInfo();
+ DeviceStatusInfo deviceStatusInfo = Global.getProject().getDeviceStatusInfo();
if (null != deviceStatusInfo) {
return deviceStatusInfo.getFunctionList();
} else {
*/
package org.tizen.dynamicanalyzer.project;
-import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicInteger;
-import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.database.DBConstants;
import org.tizen.dynamicanalyzer.database.DBTable;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
package org.tizen.dynamicanalyzer.project;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.HashMap;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.Map;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathConstants;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.database.DBTableRegistry;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.model.DeviceInfo;
-import org.tizen.dynamicanalyzer.project.data.FunctionNameDBTable;
import org.tizen.dynamicanalyzer.project.data.BinaryInfoDBTable;
+import org.tizen.dynamicanalyzer.project.data.FunctionNameDBTable;
import org.tizen.dynamicanalyzer.project.data.MemoryMapDBTable;
import org.tizen.dynamicanalyzer.project.data.ProcessInfoDBTable;
import org.tizen.dynamicanalyzer.sql.SqlManager;
}
}
- AnalyzerManager.setProject(this);
+ Global.setProject(this);
// close previous database connection
SqlConnectionManager.closeConnection();
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.project.Project;
private boolean isQueryPrint = false;
private Connection getConnection() {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
if (null != project && !AnalyzerManager.isExit()) {
return getConnection(project.getSavePath());
}
import org.tizen.dynamicanalyzer.swap.platform.BinarySettingManager;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackInserter;
-import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackItem;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
}
public String getUserFunctionPosition(int pid, long time) {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
ProcessInformation process = project.getProcessInformation(pid);
ProcessMemoryMap pmap = process.getProcessMemoryMap(time);
}
public boolean checkUserCall(String input) {
- AppInfo appInfo = AnalyzerManager.getProject().getApplicationInfo();
- BinaryInfo binfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ AppInfo appInfo = Global.getProject().getApplicationInfo();
+ BinaryInfo binfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(appInfo.getExecBinaryPath());
if (binfo.getTargetBinaryPath().equals(input)) {
return true;
String functionName = null;
String symbol = null;
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
ProcessInformation process = project.getProcessInformation(pid);
ProcessMemoryMap pmap = process.getProcessMemoryMap(time);
LibraryObject libraryObject = pmap.getLibraryByAddress(addr);
if (null != libraryObject) {
int binaryID = libraryObject.getBinaryID();
- BinaryInfo binfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(binaryID);
String path = binfo.getTargetBinaryPath();
import java.util.NavigableMap;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
import org.tizen.dynamicanalyzer.project.FunctionNameManager;
if (null == selfCallstackUnit) {
String strSelfFuncName = FunctionNameManager.getFunctionName(log.getApiId());
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(log.getBinaryId());
String strSelfSymbol = binInfo.getTargetBinaryPath()
+ AnalyzerConstants.CALLSTACK_API_TOKEN_STRING + strSelfFuncName;
String apiName = FunctionNameManager.getFunctionName(log.getApiId());
if (apiName.equals("main")) { //$NON-NLS-1$
- ProcessInformation process = AnalyzerManager.getProject().getProcessInformation(
+ ProcessInformation process = Global.getProject().getProcessInformation(
log.getPid());
process.setDropLog(true);
}
// TODO: use callstackunit made during trace time
if (null == selfCallstackUnit) {
String strSelfFuncName = FunctionNameManager.getFunctionName(pData.getApiId());
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(pData.getBinaryId());
String strSelfSymbol = binInfo.getTargetBinaryPath()
+ AnalyzerConstants.CALLSTACK_API_TOKEN_STRING + strSelfFuncName;
}
public boolean isAddrInBinaryRange(int pid, long time, long addr) {
- ProcessMemoryMap pmap = AnalyzerManager.getProject().getProcessInformation(pid)
+ ProcessMemoryMap pmap = Global.getProject().getProcessInformation(pid)
.getProcessMemoryMap(time);
if (null == pmap) {
return false;
int size = binPaths.size();
for (int i = 0; i < size; i++) {
String binPath = binPaths.get(i);
- BinaryInfo bininfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo bininfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(binPath);
LibraryObject libObj = pmap.getLibraryByBinaryID(bininfo.getID());
if (null == libObj) {
}
public boolean isPieBuild(int pid, long time) {
- ProcessMemoryMap pmap = AnalyzerManager.getProject().getProcessInformation(pid)
+ ProcessMemoryMap pmap = Global.getProject().getProcessInformation(pid)
.getProcessMemoryMap(time);
if (null == pmap) {
return false;
}
LibraryObject obj = pmap.getMainbinary();
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(obj.getBinaryID());
if (null == binInfo || binInfo.getType() != 1) {
*/
package org.tizen.dynamicanalyzer.swap.channel.data;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.swap.model.DATime;
int nano = (int) (time % 10000);
nano *= 100000;
- DATime startTime = AnalyzerManager.getProject().getProfilingStartTime();
+ DATime startTime = Global.getProject().getProfilingStartTime();
int startSec = startTime.getSec();
int startNano = startTime.getNano();
Logger.debug("if show this log then process info is not comming or late!!");
startTime.setSec(sec);
startTime.setNano(nano);
- AnalyzerManager.getProject().setProfilingStartTime(startTime);
+ Global.getProject().setProfilingStartTime(startTime);
startSec = sec;
startNano = nano;
}
index += INT_SIZE;
int nano = ByteUtil.toInt(data, index);
- AnalyzerManager.getProject().setProfilingStartTime(new DATime(sec, nano));
+ Global.getProject().setProfilingStartTime(new DATime(sec, nano));
}
} else {
DACommunicator.setRunning(false);
Map<Integer, String> selectedProcess = apps.get(0).getRunningProcesses();
if (selectedProcess != null && selectedProcess.size() > 0) {
for (Map.Entry<Integer, String> entry : selectedProcess.entrySet()) {
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(entry.getValue());
String temppath = binInfo.getTempBinaryPath();
if (temppath == null) {
continue;
}
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(app.getExecBinaryPath());
String temppath = binInfo.getTempBinaryPath();
if (temppath == null) {
if (isCorrectAck(MSG_CONFIG_ACK, result)) {
if (AnalyzerManager.isRunning()) {
rt.setApplyTime(ToolbarArea.getInstance().getTime());
- AnalyzerManager.getProject().addConfigHistory(rt);
+ Global.getProject().addConfigHistory(rt);
} else {
rt.setApplyTime(0); // set time of configuration to zero
}
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler;
}
private void processProcessInfo(byte[] data) {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
int pid = 0;
int ppid = 0;
}
private void memoryMapChanged(byte[] data) {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
/** parsing */
int index = 0;
String name = ByteUtil.getString(data, index);
index += ByteUtil.getStringLength(data, index);
- ProcessInformation process = AnalyzerManager.getProject().getProcessInformation(pid);
+ ProcessInformation process = Global.getProject().getProcessInformation(pid);
if (null != process) {
process.setProcessName(name);
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.model.ImageInfo;
import org.tizen.dynamicanalyzer.project.FunctionNameManager;
-import org.tizen.dynamicanalyzer.project.ProcessInformation;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.model.data.ContextSwitchData;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
// if (pData.getProbeType()
// == AnalyzerConstants.FUNCTION_TYPE_APPINST) {
-// ProcessInformation process = AnalyzerManager.getProject()
+// ProcessInformation process = Global.getProject()
// .getProcessInformation(pData.getPid());
if(pData.getProbeType() != AnalyzerConstants.FUNCTION_TYPE_FILE) {
int apiId = SymbolManager.getFuncId(pData, pData.getPcAddr(),
private void processImage(final String from, final int angle) {
final String fileName = getImageName(from);
- final String to = AnalyzerManager.getProject().getSavePath() + File.separator
+ final String to = Global.getProject().getSavePath() + File.separator
+ AnalyzerConstants.IMAGE_FOLDER_NAME + File.separator + fileName;
if (angle != 0) {
Logger.debug("[ image rotate : " + angle + " ]");
if (null != res && res.isOk()) {
DACommunicator.removeCommand(from);
/* image resizing */
- String smallImagePath = AnalyzerManager.getProject()
+ String smallImagePath = Global.getProject()
.getSavePath()
+ File.separator
+ AnalyzerConstants.IMAGE_FOLDER_NAME
File file = new File(path);
if (file.exists()) {
/* image resizing */
- String smallImagePath = AnalyzerManager.getProject()
+ String smallImagePath = Global.getProject()
.getSavePath()
+ File.separator
+ AnalyzerConstants.IMAGE_FOLDER_NAME
import java.sql.ResultSet;
import java.sql.SQLException;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.swap.model.DATime;
-import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.dynamicanalyzer.util.ByteUtil;
import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
public abstract class LogData implements Cloneable {
public static boolean isSWAP = false;
long nano = ByteUtil.toInt(data, index);
index += INT_SIZE;
- DATime startTime = AnalyzerManager.getProject().getProfilingStartTime();
+ DATime startTime = Global.getProject().getProfilingStartTime();
long startSec = startTime.getSec();
long startNano = startTime.getNano();
long resultSec = sec - startSec;
import java.sql.SQLException;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
import org.tizen.dynamicanalyzer.project.FunctionNameManager;
import org.tizen.dynamicanalyzer.project.LibraryObject;
reserved2 = ByteUtil.toInt(data, index);
index += INT_SIZE;
- ProcessInformation process = AnalyzerManager.getProject().getProcessInformation(
+ ProcessInformation process = Global.getProject().getProcessInformation(
pid);
if (time > 0) {
LibraryObject obj = null;
if (pmap == null || (obj = pmap.getLibraryByAddress(callerAddress)) == null) {
libName = "unknown";
} else {
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(obj.getBinaryID());
libName = binInfo.getTargetBinaryPath();
}
import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_FUNCTION_EXIT;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.project.LibraryObject;
import org.tizen.dynamicanalyzer.project.ProcessInformation;
import org.tizen.dynamicanalyzer.project.ProcessMemoryMap;
}
if (probeType != AnalyzerConstants.FUNCTION_TYPE_FILE) {
- ProcessInformation process = AnalyzerManager.getProject().getProcessInformation(
+ ProcessInformation process = Global.getProject().getProcessInformation(
pid);
if (null == process) {
Logger.error("ProfileData of type: " + id + " is from wrong process: " + pid
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.swap.model.RecordEventObject;
eventTime.setSec(sec);
eventTime.setNano(nano);
- DATime startTime = AnalyzerManager.getProject().getProfilingStartTime();
+ DATime startTime = Global.getProject().getProfilingStartTime();
long startSec = startTime.getSec();
long startNano = startTime.getNano();
long resultSec = sec - startSec;
import java.sql.ResultSet;
import java.sql.SQLException;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.util.ByteUtil;
import org.tizen.dynamicanalyzer.util.Logger;
public boolean makeData(byte[] data) {
super.makeData(data);
// index = MessageParser.MSG_HEADER_SIZE;
- int coreCount = AnalyzerManager.getProject().getDeviceStatusInfo()
+ int coreCount = Global.getProject().getDeviceStatusInfo()
.getCpuCount();
- int deviceCount = AnalyzerManager.getProject().getDeviceStatusInfo()
+ int deviceCount = Global.getProject().getDeviceStatusInfo()
.getDeviceCount();
cpuFrequency = parseCpu(index, data);
}
private static String parseCpu(int start, byte[] payload) {
- int coreCount = AnalyzerManager.getProject().getDeviceStatusInfo()
+ int coreCount = Global.getProject().getDeviceStatusInfo()
.getCpuCount();
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < coreCount; i++) {
}
private static String parseUsage(int start, byte[] payload) {
- int count = AnalyzerManager.getProject().getDeviceStatusInfo()
+ int count = Global.getProject().getDeviceStatusInfo()
.getDeviceCount();
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < count; i++) {
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.appearance.DesignConstants;
import org.tizen.dynamicanalyzer.common.Global;
-import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.nl.WidgetLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.swap.platform.ui.ExplorerUtil;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.project.FunctionNameManager;
import org.tizen.dynamicanalyzer.swap.model.data.FileData;
+import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
+import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.widgets.table.DAApiListTableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.utils.Formatter;
-import org.tizen.dynamicanalyzer.ui.file.FilePage;
-import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
-import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
public class FileApiListTable extends DAApiListTableComposite {
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.nl.FilePageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
import org.tizen.dynamicanalyzer.ui.file.model.FileSelectedData;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.widgets.table.TableColumnSizePackListener;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewData;
-import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
public class FileApiListView extends DAViewComposite {
private long analysisStartTime = 0;
import org.tizen.dynamicanalyzer.utils.Formatter;
import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.ui.common.SetRangeMarkerMouseMoveListener;
import org.tizen.dynamicanalyzer.ui.common.UICommonConstants;
-import org.tizen.dynamicanalyzer.ui.file.FilePage;
-import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
+import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.timeline.logparser.LifecycleLogParser;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.shortcut.ShortCutManager;
import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
+import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
import org.tizen.dynamicanalyzer.ui.page.ScreenshotTabComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
-import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
public class FilePage extends DAPageComposite {
// page and view IDs
import java.util.ArrayList;
-
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
String[] splitApiFilePath = filePath.split(CommonConstants.SLASH);
String strApiFilePath = new String(
splitApiFilePath[splitApiFilePath.length - 1].trim());
- if (AnalyzerManager.getProject().getPackageID().equals(strApiFilePath)) {
+ if (Global.getProject().getPackageID().equals(strApiFilePath)) {
return true;
}
}
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.swap.model.data.FileData;
import org.tizen.dynamicanalyzer.ui.file.data.FileApiDB;
-import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
public class FileEvent extends FileData{
// TODO considering apiId
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.ui.file.data.FileAccessDB;
import org.tizen.dynamicanalyzer.ui.file.data.FileStatusDB;
public class FileStatus {
import java.util.concurrent.ConcurrentLinkedQueue;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
// inserter thread for callstackdata, callstackunit
try {
insertRowData.add(new Integer(csu.getPid()));
insertRowData.add(new Integer(csu.getFunctionId()));
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(csu.getPath());
insertRowData.add(new Integer(binInfo.getID()));
insertRowData.add(new Long(csu.getAddr()));
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.SymbolManager;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.logparser.LogParser;
UserFunctionData log = (UserFunctionData) input;
Map<Long, CallStackUnit> addrMap = getCallStackApiAddrByPidMap(log.getPid());
boolean isPieBuild = AnalyzerUtil.isPieBuild(log.getPid(), log.getTime());
- ProcessMemoryMap pmap = AnalyzerManager.getProject()
+ ProcessMemoryMap pmap = Global.getProject()
.getProcessInformation(log.getPid()).getProcessMemoryMap(log.getTime());
if (pmap == null) {
return;
UserFunctionData log = (UserFunctionData) input;
Map<Long, CallStackUnit> addrMap = getCallStackApiAddrByPidMap(log.getPid());
boolean isPieBuild = AnalyzerUtil.isPieBuild(log.getPid(), log.getTime());
- ProcessMemoryMap pmap = AnalyzerManager.getProject()
+ ProcessMemoryMap pmap = Global.getProject()
.getProcessInformation(log.getPid()).getProcessMemoryMap(log.getTime());
if (pmap == null) {
return;
Map<Long, CallStackUnit> addrMap = getCallStackApiAddrByPidMap(inputData.getPid());
boolean isPieBuild = AnalyzerUtil.isPieBuild(inputData.getPid(),
inputData.getTime());
- ProcessMemoryMap pmap = AnalyzerManager.getProject()
+ ProcessMemoryMap pmap = Global.getProject()
.getProcessInformation(inputData.getPid())
.getProcessMemoryMap(inputData.getTime());
if (pmap == null) {
package org.tizen.dynamicanalyzer.ui.info.callstack;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
this.functionId = functionId;
this.functionName = FunctionNameManager.getFunctionName(functionId);
- BinaryInfo bInfo = AnalyzerManager.getProject().getDeviceStatusInfo().getBinaryInfo(binaryId);
+ BinaryInfo bInfo = Global.getProject().getDeviceStatusInfo().getBinaryInfo(binaryId);
this.path = bInfo.getTargetBinaryPath();
offset = CommonConstants.EMPTY;
etc = CommonConstants.EMPTY;
import org.json.simple.JSONObject;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.JsonUtil;
public String getFilePath() {
String filepath, filename;
filename = "snapshot" + filecount;
- filepath = AnalyzerManager.getProject().getSavePath()
+ filepath = Global.getProject().getSavePath()
+ File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
+ File.separator + filename;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.ScreenshotConstants;
import org.tizen.dynamicanalyzer.model.ImageInfo;
import org.tizen.dynamicanalyzer.resources.ColorResources;
if (imageInfo.getSeq().equals("-1") || index < 0) { //$NON-NLS-1$
path = AnalyzerConstants.DEFAULT_IMAGE_NAME;
} else {
- path = AnalyzerManager.getProject().getSavePath()
+ path = Global.getProject().getSavePath()
+ File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
+ File.separator + imageInfo.getFileName();
}
package org.tizen.dynamicanalyzer.ui.info.screenshot;
-import java.util.Map;
import java.util.HashMap;
+import java.util.Map;
public class ListenMap <T> {
import java.util.Map;
import org.json.simple.JSONObject;
-import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.dynamicanalyzer.utils.JsonUtil;
import org.tizen.dynamicanalyzer.ui.info.screenshot.ecs.Ecs.Master;
import org.tizen.dynamicanalyzer.ui.info.screenshot.ecs.EcsIds.Master_Type;
+import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.utils.JsonUtil;
public class MsgMgr {
private Map<Master_Type, IMsgProc> _msg_map = new HashMap<Master_Type, IMsgProc>();
import org.eclipse.swt.widgets.Listener;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.resources.ColorResources;
cpuUsage.add(value);
}
- long totalMem = AnalyzerManager.getProject().getDeviceStatusInfo().getSystemMemorySize();
+ long totalMem = Global.getProject().getDeviceStatusInfo().getSystemMemorySize();
maxMem = totalMem;
/*
cpuUsage.add(cpuRates.get(i));
}
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
if (project != null)
maxMem = project.getDeviceStatusInfo().getSystemMemorySize();
processMem = dataManager.getLastProcessMemory();
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardHeightChangeableItem;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItemList;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardHeightChangeableItem;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
import org.tizen.dynamicanalyzer.nl.KernelPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
-import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.ui.common.SetRangeMarkerMouseMoveListener;
import org.tizen.dynamicanalyzer.ui.common.UICommonConstants;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.opengl.GLPage;
import org.tizen.dynamicanalyzer.ui.opengl.data.GLDataManager;
import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLAPIData;
-import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLES20ErrorDefine;
import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLConstantDefine;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLES20ErrorDefine;
import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLSelectionData;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.ui.timeline.calltrace.FunctionEntryDBTable;
import org.tizen.dynamicanalyzer.ui.timeline.calltrace.FunctionExitDBTable;
+import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButton;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonClickEventListener;
import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DATabButton;
import org.tizen.dynamicanalyzer.widgets.da.view.DATabComposite;
-import org.tizen.dynamicanalyzer.util.Logger;
public class RangeDataManager implements Runnable {
private static RangeDataManager instance = null;
import org.tizen.dynamicanalyzer.ui.summary.failed.FailedApiDataMaker;
import org.tizen.dynamicanalyzer.ui.summary.leaks.CurrentLeakData;
import org.tizen.dynamicanalyzer.ui.summary.leaks.FreeDataDBTable;
+import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDataDBTable;
import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDataMaker;
import org.tizen.dynamicanalyzer.ui.summary.leaks.MemoryAllocationDataDBTable;
-import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDataDBTable;
import org.tizen.dynamicanalyzer.ui.summary.leaks.NewLeakDetector;
import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataDBTable;
import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataMaker;
import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
import org.tizen.dynamicanalyzer.ui.page.ScreenshotTabComposite;
import org.tizen.dynamicanalyzer.ui.summary.failed.FailedApiListView;
-import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakView;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfilingView;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
-import java.util.Map;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathManager;
-import org.tizen.dynamicanalyzer.database.DBConstants;
import org.tizen.dynamicanalyzer.database.DBTable;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
import org.tizen.dynamicanalyzer.widgets.da.base.DADialog;
public class LeakDataMaker {
public void makeLeakDataForRange(Long startTime, Long endTime) {
clearLeakDataForRange();
- int[] pids = AnalyzerManager.getProject().getProcessIDs();
+ int[] pids = Global.getProject().getProcessIDs();
for (int i = 0; i < pids.length; i++) {
List<List<Object>> allocDataList = getAllocationDataWithPidFromDBForRange(startTime,
endTime, pids[i]);
import java.util.SortedMap;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.ConfigureLabels;
import org.tizen.dynamicanalyzer.nl.SummaryLabels;
insertRowData.add(new Byte(type));
if (pData.isParent()) { // library
insertRowData.add(new Integer(pData.getFunctionId())); // -1 (default value)
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(pData.getName());
insertRowData.add(new Integer(binInfo.getID()));
} else { // function
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData;
import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
-import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataDBInserter;
-import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataDBTable;
public class WarningDataMaker {
private static int warningSeq = 1;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.SummaryLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
-import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
import org.tizen.dynamicanalyzer.ui.summary.SummaryPage;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
package org.tizen.dynamicanalyzer.ui.thread.sync;
import java.util.ArrayList;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
-import java.util.Comparator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
package org.tizen.dynamicanalyzer.ui.thread.thread;
import java.util.ArrayList;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
-import java.util.Comparator;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.SymbolManager;
import java.util.List;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.project.ProcessInformation;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
insertData.add(insertRowData);
// for calltrace table windowing
- ProcessInformation process = AnalyzerManager.getProject()
+ ProcessInformation process = Global.getProject()
.getProcessInformation(pData.getPid());
process.addFunctionEntryLogCount();
}
import java.util.ArrayList;
import java.util.List;
+
import org.eclipse.nebula.widgets.grid.Grid;
import org.eclipse.nebula.widgets.grid.GridItem;
import org.eclipse.swt.events.SelectionEvent;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
import org.tizen.dynamicanalyzer.project.FunctionNameManager;
// TODO: ret value
text.add("");
int binaryId = (Integer) rowData.get(FunctionEntryDBTable.COLUMN.BINARYID.index);
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(binaryId);
text.add(binInfo.getTargetBinaryPath());
}
public int getItemCountByPid() {
- if (null == AnalyzerManager.getProject()) {
+ if (null == Global.getProject()) {
return 0;
}
int itemCount = 0;
int selectedPid = ToolbarArea.getInstance().getSelectedPid();
if (selectedPid != 0) {
- ProcessInformation process = AnalyzerManager.getProject()
+ ProcessInformation process = Global.getProject()
.getProcessInformation(selectedPid);
itemCount = process.getFunctionEntryLogCount();
} else {
- itemCount = AnalyzerManager.getProject().getTotalFunctionEntryCount();
+ itemCount = Global.getProject().getTotalFunctionEntryCount();
}
return itemCount;
}
import java.util.Map;
import org.eclipse.swt.widgets.Display;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
appLoadSeries.clear();
totalLoadSeries.clear();
- if (AnalyzerManager.getProject() == null) {
+ if (Global.getProject() == null) {
return;
}
- int coreSize = AnalyzerManager.getProject().getDeviceStatusInfo().getCpuCount();
+ int coreSize = Global.getProject().getDeviceStatusInfo().getCpuCount();
Collection<DAChartSeries> processSeries = childSeriesMap.values();
if (processSeries != null) {
import java.util.List;
import org.eclipse.swt.graphics.Color;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
@Override
public void inputChartSeries(List<Object> dataList) {
if (coreSize == TimelineConstants.NOT_INITED) {
- if (AnalyzerManager.getProject() == null) {
+ if (Global.getProject() == null) {
return;
}
- coreSize = AnalyzerManager.getProject().getDeviceStatusInfo().getCpuCount();
+ coreSize = Global.getProject().getDeviceStatusInfo().getCpuCount();
for (int i = 0; i < coreSize; i++) {
DAChartSeries chartSeries = new DAChartSeries(
TimelineChartLabels.CPU_CORE_CHART_SERIES_NAME_CORE + i,
import java.util.List;
import org.eclipse.swt.graphics.Color;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
@Override
public void inputChartSeries(List<Object> dataList) {
if (coreSize == TimelineConstants.NOT_INITED) {
- if (AnalyzerManager.getProject() == null) {
+ if (Global.getProject() == null) {
return;
}
- coreSize = AnalyzerManager.getProject().getDeviceStatusInfo().getCpuCount();
+ coreSize = Global.getProject().getDeviceStatusInfo().getCpuCount();
for (int i = 0; i < coreSize; i++) {
DAChartSeries chartSeries = new DAChartSeries(
TimelineChartLabels.CPU_CORE_CHART_SERIES_NAME_CORE + i,
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
try {
if (chart.getSeriesList().isEmpty()) {
- if (AnalyzerManager.getProject() == null) {
+ if (Global.getProject() == null) {
return;
}
chart.addSeries(energyUsageSeries);
- String[] deviceList = AnalyzerManager.getProject().getDeviceStatusInfo()
+ String[] deviceList = Global.getProject().getDeviceStatusInfo()
.getDevices().split(CommonConstants.COMMA);
for (String device : deviceList) {
deviceUsageSeriesList.add(new DAChartSeries(device,
import java.util.Map;
import org.eclipse.swt.widgets.Display;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
import org.tizen.dynamicanalyzer.project.LibraryObject;
/*
* Add additional library allocation
*/
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
List<BinarySettingData> binDataList = BinarySettingManager.getInstance()
.getBinarySettingList();
ProcessMemoryMap pmap = project.getProcessInformation(pid).getProcessMemoryMap(
}
}
- if (AnalyzerManager.getProject() == null) {
+ if (Global.getProject() == null) {
return;
}
import java.util.Map;
import org.eclipse.swt.widgets.Display;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
}
}
- if (AnalyzerManager.getProject() == null) {
+ if (Global.getProject() == null) {
return;
}
@SuppressWarnings("unchecked")
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
/ TimelineConstants.MEGA_DOUBLE;
String fileName = (String)row.get(ScreenShotDBTable.COLUMN.IMAGE_FILE_PATH.ordinal());
int orientation = (Integer)row.get(ScreenShotDBTable.COLUMN.IMAGE_ORIENTATION.ordinal());
- if (AnalyzerManager.getProject() == null) {
+ if (Global.getProject() == null) {
return;
}
- String imagePath = AnalyzerManager.getProject().getSavePath()
+ String imagePath = Global.getProject().getSavePath()
+ File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
+ File.separator
+ AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME
import java.util.List;
import java.util.Map;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
systemSeries.clear();
totalSeries.clear();
- if (AnalyzerManager.getProject() == null) {
+ if (Global.getProject() == null) {
return;
}
- long systemMemorySize = AnalyzerManager.getProject()
+ long systemMemorySize = Global.getProject()
.getDeviceStatusInfo().getSystemMemorySize();
@SuppressWarnings("unchecked")
import java.util.List;
import java.util.Map;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
}
private void makeSystemDataTableData(Logs systemLogs, Logs memoryLogs) {
- int coreSize = AnalyzerManager.getProject().getDeviceStatusInfo().getCpuCount();
+ int coreSize = Global.getProject().getDeviceStatusInfo().getCpuCount();
List<LogData> memoryLogList = memoryLogs == null ? null : memoryLogs.getRawLogs();
List<LogData> systemLogList = systemLogs == null ? null : systemLogs.getRawLogs();
* Check library allocation
*/
String binaryPath = null;
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
ProcessMemoryMap pmap = project.getProcessInformation(logData.getPid()).getProcessMemoryMap(
logData.getTime());
LibraryObject lib = pmap.getLibraryByAddress(logData.getCallerPcAddr());
import java.util.List;
import org.eclipse.swt.graphics.Color;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.project.AppInfo;
import org.tizen.dynamicanalyzer.resources.ColorResources;
Color color;
String text;
- if(AnalyzerManager.getProject() == null) {
+ if(Global.getProject() == null) {
return;
}
/*
* TODO need to check detail application type
*/
// EFL
- if (AnalyzerManager.getProject().getApplicationInfo().getAppType().
+ if (Global.getProject().getApplicationInfo().getAppType().
contains(AppInfo.APPTYPE_CAPP)) {
if (apiId == API_ID_INITIALIZING_EFL) {
Logger.performance("TEST", "EFL App Lifecycle", "Initializing");
}
}
// OSP
- else if (AnalyzerManager.getProject().getApplicationInfo().getAppType().
+ else if (Global.getProject().getApplicationInfo().getAppType().
contains(AppInfo.APPTYPE_CPP)) {
if (apiId == API_ID_INITIALIZING_OSP) {
Logger.performance("TEST", "OSP App Lifecycle", "Initializing");
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.appearance.DesignConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.nl.WidgetLabels;
};
private String getDefaultSaveFileName() {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
String sourcePath = project.getSavePath();
String[] splitSourcePath = null;
if (CommonUtil.isWin()) {
import org.eclipse.swt.widgets.Display;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.logparser.LogParser;
import org.tizen.dynamicanalyzer.project.Project;
@Override
public void run() {
Logger.performanceSubThreadStart("TEST", "DA end", "Run stop log process thread");
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
int percent = 0;
int exitCount = 0;
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- Project p = AnalyzerManager.getProject();
+ Project p = Global.getProject();
if (null == p || !p.isValid() || !enabled) {
replayButton.setButtonEnabled(false);
replayEditButton.setButtonEnabled(false);
@Override
public void handleEvent(Event event) {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
if (null == project) {
return;
}
public void stopTrace() {
ShortCutManager.getInstance().setEnabled(false);
- AnalyzerManager.getProject().setReplayStopTime(getTime());
+ Global.getProject().setReplayStopTime(getTime());
AnalyzerManager.setRunningState(false);
AnalyzerManager.stopScreenshotTimer();
TraceStartStopThread.runStartStopThread();
package org.tizen.dynamicanalyzer.ui.toolbar;
-import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.*;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.START_STOP_THREAD;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
package org.tizen.dynamicanalyzer.ui.toolbar.opentrace;
-import java.util.List;
-
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.project.Project;
-import org.tizen.dynamicanalyzer.sql.SqlManager;
-import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
-import org.tizen.dynamicanalyzer.swap.logparser.Logs;
-import org.tizen.dynamicanalyzer.swap.model.data.LogData;
-import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory;
import org.tizen.dynamicanalyzer.util.Logger;
public class OpenTraceInputReader implements Runnable {
@Override
public void run() {
AnalyzerManager.setLogParsingComplete(false);
- Project p = AnalyzerManager.getProject();
+ Project p = Global.getProject();
// deprecated
// createPackage(p.getDeviceLogCount(),
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.handlers.ClearHandler;
import org.tizen.dynamicanalyzer.handlers.OpenTraceCompleteHandler;
import org.tizen.dynamicanalyzer.handlers.OpenTraceHandler;
public void run() {
AnalyzerUtil.executeCommand(ClearHandler.ID);
Project project = new Project();
- AnalyzerManager.setProjectNoRegist(project);
+ Global.setProject(project);
project.setSavePath(getInstance().getSavePath());
AnalyzerUtil.executeCommand(OpenTraceHandler.ID);
}
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
String path = PathManager.DA_SAVE_PATH + File.separator
+ text.get(TRACE_NAME_INDEX);
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
if (null != project) {
String projectPath = project.getSavePath();
if (path.equals(projectPath)) {
import org.eclipse.nebula.widgets.grid.GridItem;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.model.TableInput;
String path = PathManager.DA_TEMP_FOLDER_PATH + File.separator
+ text.get(TRACE_NAME_INDEX);
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
if (null != project) {
String projectPath = project.getSavePath();
if (path.equals(projectPath)) {
import org.eclipse.swt.widgets.Text;
import org.tizen.dynamicanalyzer.appearance.DesignConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
};
private String getSaveFileName() {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
String sourcePath = project.getSavePath();
String[] splitSourcePath = null;
if (CommonUtil.isWin()) {
}
private boolean executeSaveTrace() {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
String sourcePath = project.getSavePath();
targetPath = PathManager.DA_SAVE_PATH + File.separator + saveFileName;
- if (AnalyzerManager.getProject().getSavePath().equals(targetPath)) {
+ if (Global.getProject().getSavePath().equals(targetPath)) {
return true;
}
import java.util.List;
import org.eclipse.swt.widgets.Shell;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.ReplayEditLabels;
import org.tizen.dynamicanalyzer.swap.model.DATime;
}
public long getTimeValue(long sec, long nano) {
- DATime startTime = AnalyzerManager.getProject().getProfilingStartTime();
+ DATime startTime = Global.getProject().getProfilingStartTime();
long startSec = startTime.getSec();
long startNano = startTime.getNano();
long resultSec = sec - startSec;
}
private DATime getDATimeValue(long time) {
- DATime startTime = AnalyzerManager.getProject().getProfilingStartTime();
+ DATime startTime = Global.getProject().getProfilingStartTime();
long startSec = startTime.getSec();
long startNano = startTime.getNano();
long delaySec = time / (1000 * 1000);
import org.eclipse.swt.widgets.Composite;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.model.ImageInfo;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
if (i == 0) {
path = AnalyzerConstants.DEFAULT_IMAGE_NAME;
} else {
- path = AnalyzerManager.getProject().getSavePath()
+ path = Global.getProject().getSavePath()
+ File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
+ File.separator + image.getFileName();
}
import java.util.ArrayList;
import java.util.List;
+
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
// int tableItemIndex = 0;
// int tableRowSize = table.getItemCount();
//
- // if (null == AnalyzerManager.getProject()) {
+ // if (null == Global.getProject()) {
// return;
// }
//
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.handlers.IHandlerService;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
import org.tizen.dynamicanalyzer.project.ProcessInformation;
}
public static String getProcessLocalBinaryPath(int pid, long time) {
- ProcessMemoryMap pmap = AnalyzerManager.getProject().getProcessInformation(pid)
+ ProcessMemoryMap pmap = Global.getProject().getProcessInformation(pid)
.getProcessMemoryMap(time);
if (null != pmap) {
- return AnalyzerManager.getProject().getDeviceStatusInfo()
+ return Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(pmap.getMainbinary().getBinaryID())
.getTargetBinaryPath();
} else {
}
public static String getBinarySourcePath(int pid, long time) {
- ProcessMemoryMap pmap = AnalyzerManager.getProject().getProcessInformation(pid)
+ ProcessMemoryMap pmap = Global.getProject().getProcessInformation(pid)
.getProcessMemoryMap(time);
if (null != pmap) {
- return AnalyzerManager.getProject().getDeviceStatusInfo()
+ return Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(pmap.getMainbinary().getBinaryID())
.getTempBinaryPath();
} else {
// need to be refactored
public static boolean isPieBuild(int pid, long time) {
- ProcessMemoryMap pmap = AnalyzerManager.getProject().getProcessInformation(pid)
+ ProcessMemoryMap pmap = Global.getProject().getProcessInformation(pid)
.getProcessMemoryMap(time);
if (null == pmap) {
return false;
}
- BinaryInfo binInfo = AnalyzerManager.getProject().getDeviceStatusInfo()
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
.getBinaryInfo(pmap.getMainbinary().getBinaryID());
if (null == binInfo || binInfo.getType() != 1) {
return false;
}
public static String getProcessName(int pid) {
- Project project = AnalyzerManager.getProject();
+ Project project = Global.getProject();
if (project == null) {
return null;
}
import java.io.IOException;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.util.CommonUtil;
String downloadFolderPath = File.separator
+ AnalyzerConstants.DOWNLOAD_FILE_FOLDER;
- makeFolder(AnalyzerManager.getProject().getSavePath()
+ makeFolder(Global.getProject().getSavePath()
+ downloadFolderPath);
String saveFilePath = downloadFolderPath + File.separator
+ fileNameSplit[SPLIT_PATH_INDEX];
- if (pullFile(deviceFilePath, AnalyzerManager.getProject()
+ if (pullFile(deviceFilePath, Global.getProject()
.getSavePath() + saveFilePath)) {
returnString = saveFilePath;
}
+ File.separator)) {
StringBuffer contextsBuffer = new StringBuffer();
- String filePath = AnalyzerManager.getProject().getSavePath()
+ String filePath = Global.getProject().getSavePath()
+ contents;
File contentsFile = new File(filePath);
if (contentsFile.isFile()) {