import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Canvas;
+ import org.eclipse.swt.widgets.Display;
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;
++<<<<<<< HEAD
+import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonRenderer;
++=======
+ import org.tizen.dynamicanalyzer.widgets.helper.ColorResources;
++>>>>>>> tizen
public class DACustomToggleButtonRenderer extends DACustomButtonRenderer {
@Override
}
public static void clear() {
+ Project project = Global.getProject();
if (null != project) {
- if (!project.isValid()) {
- String sourcePath = project.getSavePath();
- if (null != sourcePath && !sourcePath.isEmpty()) {
- boolean success = AnalyzerUtil.deleteFile(new File(sourcePath));
- if (success) {
- // logs for debug
- Logger.debug("invalid project deleted!"); //$NON-NLS-1$
- } else {
- Logger.debug("invalid project delete fail..."); //$NON-NLS-1$
+ synchronized (project) {
+ if (!project.isValid()) {
+ String sourcePath = project.getSavePath();
+ if (null != sourcePath && !sourcePath.isEmpty()) {
+ boolean success = AnalyzerUtil.deleteFile(new File(sourcePath));
+ if (success) {
+ // logs for debug
+ Logger.debug("invalid project deleted!"); //$NON-NLS-1$
+ } else {
+ Logger.debug("invalid project delete fail..."); //$NON-NLS-1$
+ }
}
}
- project = null;
+ project.dispose();
++ Global.setProject(null);
}
- project.dispose();
- Global.setProject(null);
}
imageSet = null;
return devNameList;
}
- public static Map<String, PackageInfo> getAppListFromTarget() {
+ public static Map<String, PackageInfo> updateAppListFromTarget() {
- DeviceInfo curDev = GlobalInformation.getCurrentDeviceInfo();
+ DeviceInfo curDev = Global.getCurrentDeviceInfo();
if (curDev == null) {
return null;
}
return processMap;
}
-
+
public static String getProcessNameFromTarget(int pid) {
- if (null == GlobalInformation.getCurrentDeviceInfo()) {
+ if (null == Global.getCurrentDeviceInfo()) {
return null;
}
String processName = null;
}
public static void closeSock() {
- GlobalInformation.getCurrentDeviceInfo().getCommunicator().closeSock();
+ Global.getCurrentDeviceInfo().getCommunicator().closeSock();
}
- public static HostResult handleControlMessage(String msg) {
- return Global.getCurrentDeviceInfo().getCommunicator().handleControlMessage(msg);
- }
-
public static Map<Integer, String> sendProcessAddInfoMessage(List<Integer> pids) {
- DeviceInfo dev = GlobalInformation.getCurrentDeviceInfo();
+ DeviceInfo dev = Global.getCurrentDeviceInfo();
if (dev != null) {
if (isSWAPVersion()) {
return ((Communicator30) dev.getCommunicator()).sendProcessAddInfoMessage(pids);
Logger.debug("auto start : " + binaryOfTarget);
DeviceInfo device = DACommunicator.getDeviceByName(deviceName);
- GlobalInformation.setCurrentDeviceInfo(device);
+ Global.setCurrentDeviceInfo(device);
- DACommunicator.getAppListFromTarget();
+ if (device == null) {
+ popupMessage(UserErrorWarningLabels.ERROR_DEVICE_CONNECTION);
+ ToolbarArea.getInstance().setToolbarStartStopState(true);
+ return;
+ }
+ DACommunicator.updateAppListFromTarget();
PackageInfo pkgInfo = null;
if (projectType.equals(PROJECT_TYPE_OSP) || projectType.equals(PROJECT_TYPE_EFL)
|| projectType.equals(PROJECT_TYPE_WEBAPP)) {
addConfigHistory(currentConfig);
}
- setAppName(Global.getCurrentApplication().getMainApp()
- .getInfo(AppInfo.PROPERTY.LABEL.index));
- setAppName(GlobalInformation.getCurrentApplication().getMainApp().getLabel());
- setPackageID(GlobalInformation.getCurrentApplication().getPackageId());
- DeviceInfo deviceName = GlobalInformation.getCurrentDeviceInfo();
++ setAppName(Global.getCurrentApplication().getMainApp().getLabel());
+ setPackageID(Global.getCurrentApplication().getPackageId());
+ DeviceInfo deviceName = Global.getCurrentDeviceInfo();
++
if (null != deviceName && null != deviceName.getIDevice().getSerialNumber()
&& !deviceName.getIDevice().getSerialNumber().isEmpty()) {
- setDevice(GlobalInformation.getCurrentDeviceInfo().getIDevice().getSerialNumber());
+ setDevice(Global.getCurrentDeviceInfo().getIDevice().getSerialNumber());
} else {
setDevice(CommonConstants.SPACE);
}
@Override
public HostResult startTrace() {
- DeviceInfo curDev = GlobalInformation.getCurrentDeviceInfo();
++ DeviceInfo curDev = Global.getCurrentDeviceInfo();
+ if (curDev == null) {
+ return HostResult.ERR_DEVICE_IS_NULL;
+ }
+
DACommunicator.setRunning(true);
UserSpaceInst userSpaceInst = getUserSpaceInst();
Logger.performance("TEST", "Start Trace", "Set application inst");
byte[] msgBinInfo = ByteUtil.toBytes(AnalyzerConstants.MSG_BINARY_INFO);
byte[] preMsg = null;
- DeviceInfo curDevice = GlobalInformation.getCurrentDeviceInfo();
+ DeviceInfo curDevice = Global.getCurrentDeviceInfo();
+ if (curDevice == null) {
+ return HostResult.ERR_DEVICE_IS_NULL;
+ }
if (AnalyzerConstants.RUNNING_PROCESS.equals(selectedPkg.getPackageId())) {
Map<Integer, String> selProcess = selectedPkg.getMainApp().getRunningProcesses();
}
}
- @Override
- public HostResult handleControlMessage(String message) {
- return HostResult.SUCCESS;
+ public HostResult handleControlMessage(byte[] message) {
- DeviceInfo curDev = GlobalInformation.getCurrentDeviceInfo();
++ DeviceInfo curDev = Global.getCurrentDeviceInfo();
+ if (curDev != null) {
+ return handleControlMessage(curDev, message);
+ } else {
+ return HostResult.ERR_DEVICE_IS_NULL;
+ }
}
public HostResult handleControlMessage(DeviceInfo device, byte[] message) {
public HostResult sendScreenShotRequest() {
byte[] msg = ByteUtil.getByte(AnalyzerConstants.MSG_GET_SCREENSHOT, 0);
- HostResult result = HostResult.SUCCESS;
- Socket controlSock = Global.getCurrentDeviceInfo().getControlSock();
- try {
- if (null != controlSock && !controlSock.isClosed()) {
- controlSock.getOutputStream().write(msg);
- } else {
- Logger.debug("control socket is closed");
- result = HostResult.ERR_CONTROL_SOCKET_CONNECTION_CLOSED;
- }
- } catch (SocketException e) {
- result = HostResult.ERR_EXCEPTION_OCCURRED;
- result.setMessage(e.getMessage());
- e.printStackTrace();
- return result;
- } catch (SocketTimeoutException e) {
- result = HostResult.ERR_EXCEPTION_OCCURRED;
- result.setMessage(e.getMessage());
- e.printStackTrace();
- return result;
- } catch (IOException e) {
- result = HostResult.ERR_EXCEPTION_OCCURRED;
- result.setMessage(e.getMessage());
- e.printStackTrace();
- return result;
- } finally {
- blocked = false;
- }
- return result;
- return handleControlMessage(GlobalInformation.getCurrentDeviceInfo(), msg, false, 0);
++ return handleControlMessage(Global.getCurrentDeviceInfo(), msg, false, 0);
}
public HostResult sendSWAPMessage(int messageId, List<BinarySettingData> settings) {
- DeviceInfo curDev = GlobalInformation.getCurrentDeviceInfo();
++ DeviceInfo curDev = Global.getCurrentDeviceInfo();
+ if (curDev == null) {
+ return HostResult.ERR_DEVICE_IS_NULL;
+ }
+
byte[] msg = new byte[0];
int count = settings.size();
int failedCount = 0;
}
public Map<Integer, String> sendProcessAddInfoMessage(List<Integer> pids) {
- DeviceInfo curDev = GlobalInformation.getCurrentDeviceInfo();
++ DeviceInfo curDev = Global.getCurrentDeviceInfo();
+ if (curDev == null) {
+ return null;
+ }
+
Map<Integer, String> infoMap = null;
int pidcount = pids.size();
int length = sendBin.length;
byte[] msg = ByteUtil.getByte(AnalyzerConstants.MSG_BINARY_INFO, length, sendBin);
- HostResult result = handleControlMessage(Global.getCurrentDeviceInfo(), msg);
++
+ HostResult result = handleControlMessage(msg);
if (!result.isSuccess() || !isCorrectAck(MSG_BINARY_INFO_ACK, result)) {
return HostResult.ERR_BIN_INFO_GET_FAIL;
// if (pData.getProbeType()
// == AnalyzerConstants.FUNCTION_TYPE_APPINST) {
- // ProcessInformation process = Global.getProject()
- // .getProcessInformation(pData.getPid());
- if(pData.getProbeType() != AnalyzerConstants.FUNCTION_TYPE_FILE) {
- // 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(),
pData.getPid(), pData.getTime());
- String apiName = FunctionNameManager.getFunctionName(apiId);
+ String apiName = Global.getFunctionName(apiId);
// TODO : <unknown function> check with apiId
if (apiId == -1 || apiName.equals("<unknown function>")) {
continue;
String remoteImgPath;
if (DACommunicator.isTargetEmulator()
&& SocketClient.getInstance().isConnected()) {
- Global.getCurrentDeviceInfo().emulatorScreenshot
- .send();
- GlobalInformation.getCurrentDeviceInfo().emulatorScreenshot.send();
- remoteImgPath = GlobalInformation.getCurrentDeviceInfo().emulatorScreenshot
++ Global.getCurrentDeviceInfo().emulatorScreenshot.send();
+ remoteImgPath = Global.getCurrentDeviceInfo().emulatorScreenshot
.getFilePath();
bECS = true;
} else {
if (null != res && res.isOk()) {
DACommunicator.removeCommand(from);
/* image resizing */
- String smallImagePath = Global.getProject()
- .getSavePath()
- + File.separator
- + AnalyzerConstants.IMAGE_FOLDER_NAME
- + File.separator
- + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME
- String smallImagePath = AnalyzerManager.getProject().getSavePath()
- + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
- + File.separator + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME
-- + File.separator + fileName;
- ImageUtil.transform(to, to, DEFAULT_IMG_WIDTH,
- DEFAULT_IMG_HEIGHT, angle);
++ String smallImagePath = Global.getProject().getSavePath() + File.separator
++ + AnalyzerConstants.IMAGE_FOLDER_NAME + File.separator
++ + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME + File.separator
++ + fileName;
+ ImageUtil.transform(to, to, DEFAULT_IMG_WIDTH, DEFAULT_IMG_HEIGHT, angle);
if (angle == 90 || angle == 270) {
- ImageUtil.resize(to, smallImagePath, SMALL_IMG_HEIGHT,
- SMALL_IMG_WIDTH);
+ ImageUtil.resize(to, smallImagePath, SMALL_IMG_HEIGHT, SMALL_IMG_WIDTH);
} else {
- ImageUtil.resize(to, smallImagePath, SMALL_IMG_WIDTH,
- SMALL_IMG_HEIGHT);
+ ImageUtil.resize(to, smallImagePath, SMALL_IMG_WIDTH, SMALL_IMG_HEIGHT);
}
break;
File file = new File(path);
if (file.exists()) {
/* image resizing */
- String smallImagePath = Global.getProject()
- .getSavePath()
- + File.separator
- + AnalyzerConstants.IMAGE_FOLDER_NAME
- + File.separator
- + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME
- String smallImagePath = AnalyzerManager.getProject().getSavePath()
- + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
- + File.separator + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME
-- + File.separator + fileName;
- ImageUtilSWT.transform(path, path, DEFAULT_IMG_WIDTH,
- DEFAULT_IMG_HEIGHT, angle);
++ String smallImagePath = Global.getProject().getSavePath() + File.separator
++ + AnalyzerConstants.IMAGE_FOLDER_NAME + File.separator
++ + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME + File.separator
++ + fileName;
+ ImageUtilSWT.transform(path, path, DEFAULT_IMG_WIDTH, DEFAULT_IMG_HEIGHT,
+ angle);
if (angle == 90 || angle == 270) {
ImageUtilSWT.resize(path, smallImagePath, SMALL_IMG_HEIGHT,
SMALL_IMG_WIDTH);
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;
import org.tizen.dynamicanalyzer.project.ProcessMemoryMap;
import org.tizen.dynamicanalyzer.swap.callstack.BaseCallstackManager;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
int fsize = functionData.size();
for (int i = 0; i < fsize; i++) {
List<Object> idata = functionData.get(i);
- int tid = (Integer) idata
- .get(FunctionDataDBTable.COLUMN.TID.index);
- int funcId = (Integer) idata
- .get(FunctionDataDBTable.COLUMN.FUNCID.index);
+ int tid = (Integer) idata.get(FunctionDataDBTable.COLUMN.TID.index);
+ int funcId = (Integer) idata.get(FunctionDataDBTable.COLUMN.FUNCID.index);
- String funcname = FunctionNameManager.getFunctionName(funcId);
+ String funcname = Global.getFunctionName(funcId);
double funcStart = (double) ((Long) idata
.get(FunctionDataDBTable.COLUMN.STARTTIME.index))
/ TimelineConstants.MEGA_DOUBLE;
* create tab pages
*/
public void createTabViewPage() {
- ConfigureManager configureManager = ConfigureManager.getInstance();
+ Set<String> selectedPageList = SettingDataManager.getInstance().getSelectedPageList(null);
List<Integer> tabViewList = new ArrayList<Integer>();
- tabViewList.add(AnalyzerConstants.PAGE_TIME_LINE); // default : timeline
- // tab
- tabViewList.add(CommonConstants.PAGE_TIME_LINE); // default : timeline tab
-
++ tabViewList.add(AnalyzerConstants.PAGE_TIME_LINE); // default(timeline tab)
+
// thread tab
- if (AnalyzerConstants.FEATURE_OFF != configureManager
- .getValueLong(ConfigureLabels.FEATURE_THREAD)) {
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_THREAD)) {
- tabViewList.add(CommonConstants.PAGE_THREAD);
+ tabViewList.add(AnalyzerConstants.PAGE_THREAD);
} // else nothing
// network tab
- if (AnalyzerConstants.FEATURE_OFF != configureManager
- .getValueLong(ConfigureLabels.FEATURE_NETWORK)) {
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_NETWORK)) {
- tabViewList.add(CommonConstants.PAGE_NETWORK);
+ tabViewList.add(AnalyzerConstants.PAGE_NETWORK);
} // else nothing
- tabViewList.add(CommonConstants.PAGE_FILE);
+ // file tab
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_FILE)) {
-
++ tabViewList.add(AnalyzerConstants.PAGE_FILE);
+ } // else nothing
++
// openGL tab
- if (AnalyzerConstants.FEATURE_OFF != configureManager
- .getValueLong(ConfigureLabels.FEATURE_OPENGL)) {
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_OPENGL)) {
- tabViewList.add(CommonConstants.PAGE_GRAPHICS);
+ tabViewList.add(AnalyzerConstants.PAGE_GRAPHICS);
} // else nothing
// kernel tab
- if (AnalyzerConstants.FEATURE_OFF != configureManager
- .getValueLong(ConfigureLabels.FEATURE_CONTEXT_SWITCH)) {
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_KERNEL)) {
- tabViewList.add(CommonConstants.PAGE_KERNEL);
+ tabViewList.add(AnalyzerConstants.PAGE_KERNEL);
} // else nothing
- // file tab
- if (AnalyzerConstants.FEATURE_OFF != configureManager
- .getValueLong(ConfigureLabels.FEATURE_FILE)) {
- tabViewList.add(AnalyzerConstants.PAGE_FILE);
- } // else nothing
-
- tabViewList.add(AnalyzerConstants.PAGE_SUMMARY); // default : summary
- // tab
- tabViewList.add(CommonConstants.PAGE_SUMMARY); // default : summary tab
++ tabViewList.add(AnalyzerConstants.PAGE_SUMMARY); // default(summary tab)
addTabViewPage(tabViewList);
}
-
+
/**
* add tab pages dynamically
- * @param tabViewList : selected tab pages for adding
+ *
+ * @param tabViewList
+ * : selected tab pages for adding
*/
public void addTabViewPage(List<Integer> tabViewList) {
DABaseComposite newPage = null;
*/
public void addTabViewPage(int tabViewType, String tabViewId) {
DABaseComposite newPage = null;
- if (!tabView.isExistingPage(tabViewId)) { // if the page does not exist,
- // add the page
- if(!tabView.isExistingPage(tabViewId)) { //if the page does not exist, add the page
++ if (!tabView.isExistingPage(tabViewId)) { // if the page does not exist, add the page
switch (tabViewType) {
- case CommonConstants.PAGE_FILE:
- newPage = new FilePage(
- tabView.getContentComposite(), SWT.NONE);
+ case AnalyzerConstants.PAGE_FILE:
+ newPage = new FilePage(tabView.getContentComposite(), SWT.NONE);
tabView.addView(newPage, false);
break;
- case CommonConstants.PAGE_GRAPHICS:
- newPage = new GLPage(
- tabView.getContentComposite(), SWT.NONE);
+ case AnalyzerConstants.PAGE_GRAPHICS:
+ newPage = new GLPage(tabView.getContentComposite(), SWT.NONE);
tabView.addView(newPage, false);
break;
- case CommonConstants.PAGE_KERNEL:
- newPage = new KernelPage(
- tabView.getContentComposite(), SWT.NONE);
+ case AnalyzerConstants.PAGE_KERNEL:
+ newPage = new KernelPage(tabView.getContentComposite(), SWT.NONE);
tabView.addView(newPage, false);
break;
- case CommonConstants.PAGE_NETWORK:
- newPage = new NetworkPage(
- tabView.getContentComposite(), SWT.NONE);
+ case AnalyzerConstants.PAGE_NETWORK:
+ newPage = new NetworkPage(tabView.getContentComposite(), SWT.NONE);
tabView.addView(newPage, false);
break;
- case CommonConstants.PAGE_SUMMARY:
- newPage = new SummaryPage(
- tabView.getContentComposite(), SWT.NONE);
+ case AnalyzerConstants.PAGE_SUMMARY:
+ newPage = new SummaryPage(tabView.getContentComposite(), SWT.NONE);
tabView.addView(newPage, false);
break;
- case CommonConstants.PAGE_THREAD:
- newPage = new ThreadPage(
- tabView.getContentComposite(), SWT.NONE);
+ case AnalyzerConstants.PAGE_THREAD:
+ newPage = new ThreadPage(tabView.getContentComposite(), SWT.NONE);
tabView.addView(newPage, false);
break;
- case CommonConstants.PAGE_TIME_LINE:
- newPage = new TimelinePage(
- tabView.getContentComposite(), SWT.NONE);
+ case AnalyzerConstants.PAGE_TIME_LINE:
+ newPage = new TimelinePage(tabView.getContentComposite(), SWT.NONE);
tabView.addView(newPage, false);
break;
- case CommonConstants.PAGE_UI:
- newPage = new UIPage(tabView.getContentComposite(),
- SWT.NONE);
+ case AnalyzerConstants.PAGE_UI:
+ newPage = new UIPage(tabView.getContentComposite(), SWT.NONE);
tabView.addView(newPage, false);
break;
default:
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+ import java.util.Set;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
-import org.tizen.dynamicanalyzer.common.GlobalInformation;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.database.DBTable;
* 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());
- if (lib != pmap.getMainbinary()) {
- BinaryInfo binfo = project.getDeviceStatusInfo().getBinaryInfo(lib.getBinaryID());
- binaryPath = binfo.getTargetBinaryPath();
- }
+ if (pmap != null) {
+ LibraryObject lib = pmap.getLibraryByAddress(logData.getCallerPcAddr());
+ if (lib != null && lib != pmap.getMainbinary()) {
+ BinaryInfo binfo = project.getDeviceStatusInfo().getBinaryInfo(lib.getBinaryID());
+ binaryPath = binfo.getTargetBinaryPath();
+ }
+ }
if (errorNo == 0 && MEM_USER == internalFlag) {
if (MEM_API_TYPE_ALLOC == memApiType || MEM_API_TYPE_FREE == memApiType) {
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;
import org.tizen.dynamicanalyzer.sql.SqlManager;
import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser;
String serial = combo.getText();
if (serial != null && !serial.equals(oldDeviceName)) {
- Global.setCurrentDeviceInfo(DACommunicator
- GlobalInformation.setCurrentDeviceInfo(DACommunicator
-- .setSelectedDeviceBySerial(serial));
++ Global.setCurrentDeviceInfo(DACommunicator.setSelectedDeviceBySerial(serial));
if (null != serial && !serial.isEmpty()) {
initAppCombo();
}
// TODO : implement to select common executable
}
- GlobalInformation.setCurrentApplication(selectedPkg);
- GlobalInformation.getCurrentDeviceInfo().getCommunicator()
- .onAppSelected(selectedPkg);
- GlobalInformation.getCurrentDeviceInfo().setSelectedPackageID(
+ Global.setCurrentApplication(selectedPkg);
- Global.getCurrentDeviceInfo().getCommunicator()
- .onAppSelected(selectedPkg);
++ Global.getCurrentDeviceInfo().getCommunicator().onAppSelected(selectedPkg);
+ Global.getCurrentDeviceInfo().setSelectedPackageID(
selectedPkg.getPackageId());
} else {
enablestart = false;
Logger.performance("TEST", "Start Trace", "Check valid application");
return;
}
-
++
+ // check setting status
+ if (checkSettingStatus() == false) {
+ return;
+ }
-
++
Logger.performance("TEST", "Start Trace", "Check valid application");
Display.getDefault().syncExec(new Runnable() {
TraceStartStopThread.runStartStopThread();
}
- if (GlobalInformation.getCurrentDeviceInfo().isConfigSuccess() == false) {
+ private boolean checkSettingStatus() {
- if (!deviceCombo.isEnabled() || null == GlobalInformation.getCurrentDeviceInfo()) {
++ if (Global.getCurrentDeviceInfo().isConfigSuccess() == false) {
+ if (SettingDialogManager.getInstance().applySwapValue() == false) {
+ // fail message box
+ Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
+ DADialog dialog = new DADialog(shell, SWT.NONE, 550, 153);
+ dialog.setIcon(ImageResources.DIALOG_WARNING_ICON);
+ dialog.setMessage(ConfigureLabels.SETTING_DIALOG_FAIL_MESSAGE);
+ dialog.open();
+
+ setToolbarStartStopState(true);
+
+ if (null == DACommunicator.getDevices() || DACommunicator.getDevices().isEmpty()) {
+ deviceCombo.setEnabled(false);
+ }
+
- if (!appCombo.isEnabled() || null == GlobalInformation.getCurrentApplication()) {
++ if (!deviceCombo.isEnabled() || null == Global.getCurrentDeviceInfo()) {
+ appCombo.setEnabled(false);
+ }
+
-// Logger.performance("TEST", "Start Trace", "Check setting information");
++ if (!appCombo.isEnabled() || null == Global.getCurrentApplication()) {
+ setStartButtonEnablement(false);
+ }
+
+ setSaveButtonEnable(false);
+
+ ShortCutManager.getInstance().setEnabled(true);
-
++ // Logger.performance("TEST", "Start Trace", "Check setting information");
+ return false;
+ }
+ }
+ return true;
+ }
++
public void stopTrace() {
ShortCutManager.getInstance().setEnabled(false);
- AnalyzerManager.getProject().setReplayStopTime(getTime());
+ Global.getProject().setReplayStopTime(getTime());
AnalyzerManager.setRunningState(false);
AnalyzerManager.stopScreenshotTimer();
TraceStartStopThread.runStartStopThread();
List<String> pkgs = appCombo.getItems();
if (pkgs != null && pkgs.size() > 0) {
PackageInfo pkgInfo = null;
- String packageID = GlobalInformation.getCurrentDeviceInfo().getSelectedPackageID();
+ String packageID = Global.getCurrentDeviceInfo().getSelectedPackageID();
- if (null != packageID && DACommunicator.getPkgInfoByPkgId(packageID) != null) {
- pkgInfo = DACommunicator.getPkgInfoByPkgId(packageID);
- appCombo.setText(pkgInfo.getMainApp().getInfo(AppInfo.PROPERTY.LABEL.index));
+ pkgInfo = DACommunicator.getPkgInfoByPkgId(packageID);
+ if (null != packageID && pkgInfo != null) {
+ appCombo.setText(pkgInfo.getMainApp().getLabel());
} else {
pkgInfo = DACommunicator.getPkgInfoByLabel(pkgs.get(0));
appCombo.select(0);
} else {
int size = items.size();
int selIndex = 0;
- String selDevice = Global.getCurrentDeviceInfo().getIDevice()
- String selDevice = GlobalInformation.getCurrentDeviceInfo().getIDevice()
-- .getSerialNumber();
++ String selDevice = Global.getCurrentDeviceInfo().getIDevice().getSerialNumber();
for (int i = 0; i < size; i++) {
deviceCombo.add(items.get(i));
if (items.get(i).equals(selDevice)) {
}
deviceCombo.select(selIndex);
- Global.setCurrentDeviceInfo(DACommunicator.getDeviceByName(items
- GlobalInformation.setCurrentDeviceInfo(DACommunicator.getDeviceByName(items
-- .get(selIndex)));
++ Global.setCurrentDeviceInfo(DACommunicator.getDeviceByName(items.get(selIndex)));
deviceCombo.setToolTipText(items.get(selIndex));
if (null == oldDevice || !oldDevice.equals(selDevice)) {
public void setAppComboTextByAppId(String id) {
PackageInfo pkgInfo = DACommunicator.getPkgInfoByMainAppID(id);
if (null != pkgInfo) {
- GlobalInformation.setCurrentApplication(pkgInfo);
- GlobalInformation.getCurrentDeviceInfo().getCommunicator().onAppSelected(pkgInfo);
- GlobalInformation.getCurrentDeviceInfo().setSelectedPackageID(pkgInfo.getPackageId());
+ Global.setCurrentApplication(pkgInfo);
+ Global.getCurrentDeviceInfo().getCommunicator().onAppSelected(pkgInfo);
+ Global.getCurrentDeviceInfo().setSelectedPackageID(pkgInfo.getPackageId());
- appCombo.setText(pkgInfo.getMainApp().getInfo(AppInfo.PROPERTY.LABEL.index));
+ appCombo.setText(pkgInfo.getMainApp().getLabel());
}
}
return;
}
- DeviceInfo curDev = GlobalInformation.getCurrentDeviceInfo();
++ DeviceInfo curDev = Global.getCurrentDeviceInfo();
+ if (curDev == null) {
+ setStartButtonState(false);
+ return;
+ }
+
String text = deviceCombo.getText();
- String device = Global.getCurrentDeviceInfo().getIDevice()
- .getSerialNumber();
+ String device = curDev.getIDevice().getSerialNumber();
if (!device.equals(text)) {
// startButton.setButtonEnabled(false);
setStartButtonState(false);
private void setStartButtonState(boolean enabled) {
if (enabled) {
- DeviceInfo device = GlobalInformation.getCurrentDeviceInfo();
-// if (null != device && device.isConfigSuccess()) {
+ DeviceInfo device = Global.getCurrentDeviceInfo();
- if (null != device && device.isConfigSuccess()) {
++ // if (null != device && device.isConfigSuccess()) {
+ if (null != device) {
startButton.setButtonEnabled(true);
}
} else {
--- /dev/null
-import org.tizen.dynamicanalyzer.common.GlobalInformation;
+ /*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Heeyoung Hwang <heeyoung1008.hwang@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+ package org.tizen.dynamicanalyzer.ui.toolbar.setting;
+
+ import java.io.BufferedReader;
+ import java.io.BufferedWriter;
+ import java.io.File;
+ import java.io.FileNotFoundException;
+ import java.io.FileReader;
+ import java.io.FileWriter;
+ import java.io.IOException;
+ import java.io.PrintWriter;
+ import java.util.ArrayList;
+ import java.util.Iterator;
+ import java.util.LinkedHashMap;
+ import java.util.List;
+ import java.util.Map;
+ import java.util.Set;
+
+ import org.tizen.common.core.application.ProfileInfo;
+ import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-
++import org.tizen.dynamicanalyzer.common.Global;
+ import org.tizen.dynamicanalyzer.common.path.PathManager;
+ import org.tizen.dynamicanalyzer.communicator.DACommunicator;
+ import org.tizen.dynamicanalyzer.constant.CommonConstants;
+ import org.tizen.dynamicanalyzer.model.DeviceInfo;
+ import org.tizen.dynamicanalyzer.nl.ConfigureLabels;
+ import org.tizen.dynamicanalyzer.util.CommonUtil;
+ import org.tizen.dynamicanalyzer.util.Logger;
+ import org.tizen.sdblib.IDevice;
+
+ public class SettingDataManager {
-
++
+ private static SettingDataManager instance = null;
+
+ public static final String READ_CSV_SEPARATOR = "\\" + CommonConstants.CMD_SPLIT;
+ public static final String WRITE_CSV_SEPARATOR = CommonConstants.CMD_SPLIT;
+ public static final String SETTING_FILE_NAME = "setting.csv";
+ public static final String FEATUER_FILE_NAME = "feature.csv";
+ public static final String TEMPLATE_FILE_NAME = "template.csv";
-
++
+ // key name in setting file
+ public static final String KEY_TARGET_LIST = "Target List";
+ public static final String KEY_SELECTED_TARGET = "Selected Target";
+ public static final String KEY_SELECTED_TEMPLATE = "Selected Template";
+ public static final String KEY_SELECTED_FEATURE_LIST = "Selected FeatureList";
+ public static final String KEY_AVAILABLE_CHART_LIST = "Available Chart List";
+ public static final String KEY_SELECTED_CHART_LIST = "Selected Chart List";
+ public static final String KEY_SHOW_INITIAL = "Show Initial";
+ public static final String AUTO_STOP = "Auto Stop";
+
+ public boolean existSettingFile = true;
+
+ // init selected information : for revert button
+ private String initTarget = null;
+ private boolean initShowInitial = false;
+ private boolean initAutoStop = false;
- private List<String> selectedChartList = null; // TODO : remove?
++
+ // setting information
+ private String selectedTarget = null;
-
++ private List<String> selectedChartList = null; // TODO : remove?
+ private boolean showInitial = false;
+ private boolean autoStop = false;
-
++
+ // available target list
+ private Map<String, TargetData> targetListMap = null;
-
++
+ // TODO : check additional property
+ private String platform = null;
+ private long internalLogLevel = 4;
+
+ private SettingDataManager() {
+ parseSettingData(FEATUER_FILE_NAME);
+ parseSettingData(TEMPLATE_FILE_NAME);
+ parseSettingData(SETTING_FILE_NAME);
+ }
+
+ public synchronized static SettingDataManager getInstance() {
+ if (instance == null) {
+ instance = new SettingDataManager();
+ }
+ return instance;
+ }
- initTemplateData(content);
++
+ public boolean isExistSettingFile() {
+ return existSettingFile;
+ }
+
+ private void parseSettingData(String fileName) {
+ File csv = new File(PathManager.DA_CONFIG_FOLDER_PATH + File.separator + fileName);
+ BufferedReader in = null;
+ String content = null;
+ try {
+ in = new BufferedReader(new FileReader(csv));
+ while (null != (content = in.readLine())) {
+ if (SETTING_FILE_NAME.equals(fileName)) {
+ initSettingData(content);
+ } else if (FEATUER_FILE_NAME.equals(fileName)) {
+ initFeatureData(content);
+ } else if (TEMPLATE_FILE_NAME.equals(fileName)) {
-
++ initTemplateData(content);
+ } else {
+ Logger.debug("unknown setting file : " + fileName);
+ }
+ }
+ } catch (FileNotFoundException e) {
+ existSettingFile = false;
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ } finally {
+ CommonUtil.tryClose(in);
+ }
+ }
-
++
+ private void initSettingData(String readData) {
+ String list[] = readData.split(READ_CSV_SEPARATOR);
+ if (list[0].equals(KEY_TARGET_LIST)) {
+ makeTargetData(list);
+ } else if (list[0].equals(KEY_SELECTED_TARGET)) {
+ selectedTarget = list[1];
+ initTarget = new String(list[1]);
+ } else if (list[0].equals(KEY_SELECTED_TEMPLATE)) {
+ setSelectedTemplate(list);
+ } else if (list[0].equals(KEY_SELECTED_FEATURE_LIST)) {
+ makeSelectedFeatureList(list);
+ } else if (list[0].equals(KEY_AVAILABLE_CHART_LIST)) {
+ makeAvailableChartList(list);
+ } else if (list[0].equals(KEY_SELECTED_CHART_LIST)) {
+ makeChartList(getSelectedChartList(), list);
+ } else if (list[0].equals(KEY_SHOW_INITIAL)) {
+ showInitial = Boolean.parseBoolean(list[1]);
+ initShowInitial = Boolean.parseBoolean(list[1]);
+ } else if (list[0].equals(AUTO_STOP)) {
+ autoStop = Boolean.parseBoolean(list[1]);
+ initAutoStop = Boolean.parseBoolean(list[1]);
+ } else {
+ if (null != list[0]) {
+ Logger.debug("unknown setting key : " + list[0]);
+ }
+ }
+ }
- Map<String, TargetData> map = getTargetListMap();
++
+ private void makeTargetData(String list[]) {
+ if (list != null) {
-
++ Map<String, TargetData> map = getTargetListMap();
+ for (int i = 1; i < list.length; i++) {
+ if (isTarget(list[i]) == false) {
+ map.put(list[i], new TargetData(list[i]));
+ } // else do nothing
+ }
+ } // else do nothing
+ }
-
++
+ private void setSelectedTemplate(String list[]) {
+ if (list != null) {
+ TargetData target = getAndCreateTarget(list[1]);
+ target.setSelectedTemplate(list[2]);
+ } // else do nothing
+ }
-
++
+ private void makeSelectedFeatureList(String list[]) {
+ if (list != null) {
+ TargetData target = getAndCreateTarget(list[1]);
+ target.makeSelectedFeatureList(list);
+ } // else do nothing
+ }
-
++
+ private void makeAvailableChartList(String list[]) {
+ if (list != null) {
+ TargetData target = getAndCreateTarget(list[1]);
+ target.makeAvailableChartList(list);
+ } // else do nothing
+ }
-
- private void initFeatureData(String readData) {
++
+ private void makeChartList(List<String> chartList, String list[]) {
+ if (list != null) {
+ for (int i = 1; i < list.length; i++) {
+ chartList.add(list[i]);
+ }
+ } // else do nothing
+ }
-
++
++ private void initFeatureData(String readData) {
+ String list[] = readData.split(READ_CSV_SEPARATOR, -1);
+ if (list != null) {
+ TargetData target = getAndCreateTarget(list[0]);
+ target.makeAvailableFeatureListMap(list);
+ }
+ }
-
++
+ private void initTemplateData(String readData) {
+ String list[] = readData.split(READ_CSV_SEPARATOR, -1);
+ if (list != null) {
+ TargetData target = getAndCreateTarget(list[0]);
+ target.makeAvailableTemplateListMap(list);
+ } // else do nothing
+ }
+
+ /**
+ * Write the setting information in the setting file.
+ */
+ private void writeSettingDataToFile() {
+ File csv = new File(PathManager.DA_CONFIG_FOLDER_PATH + File.separator + SETTING_FILE_NAME);
- printWriter.println(KEY_SHOW_INITIAL + WRITE_CSV_SEPARATOR + String.valueOf(showInitial));
++
+ FileWriter fileWriter = null;
+ BufferedWriter buffWriter = null;
+ PrintWriter printWriter = null;
+ try {
+ fileWriter = new FileWriter(csv);
+ buffWriter = new BufferedWriter(fileWriter);
+ printWriter = new PrintWriter(buffWriter);
+
+ printWriter.println(writeTargetData());
+ printWriter.println(KEY_SELECTED_TARGET + WRITE_CSV_SEPARATOR + selectedTarget);
+ printWriter.println(writeChartList(getSelectedChartList(), KEY_SELECTED_CHART_LIST));
-
++ printWriter.println(KEY_SHOW_INITIAL + WRITE_CSV_SEPARATOR
++ + String.valueOf(showInitial));
+ printWriter.println(AUTO_STOP + WRITE_CSV_SEPARATOR + String.valueOf(autoStop));
- Map<String, TargetData> map = getTargetListMap();
++
+ // target : selected Template, selected feature, available chart list
- printWriter.checkError();
++ Map<String, TargetData> map = getTargetListMap();
+ for (Map.Entry<String, TargetData> entry : map.entrySet()) {
+ TargetData target = entry.getValue();
+ target.writeSelectedData(printWriter);
+ }
+
-
++ printWriter.checkError();
+ } catch (IOException e) {
+ e.printStackTrace();
+ } finally {
+ CommonUtil.tryClose(fileWriter, buffWriter, printWriter);
+ }
+ }
- buffer.append(KEY_TARGET_LIST);
-
++
+ private String writeTargetData() {
+ Map<String, TargetData> map = getTargetListMap();
+ Set<String> targetNameList = map.keySet();
+ StringBuffer buffer = new StringBuffer();
- while(iter.hasNext()) {
++ buffer.append(KEY_TARGET_LIST);
++
+ Iterator<String> iter = targetNameList.iterator();
-
++ while (iter.hasNext()) {
+ buffer.append(WRITE_CSV_SEPARATOR + iter.next());
+ }
+ return buffer.toString();
+ }
- buffer.append(key + WRITE_CSV_SEPARATOR);
-
++
+ private String writeChartList(List<String> list, String key) {
+ StringBuffer buffer = new StringBuffer();
- if (i < list.size() -1) {
++ buffer.append(key + WRITE_CSV_SEPARATOR);
++
+ for (int i = 0; i < list.size(); i++) {
-
++ if (i < list.size() - 1) {
+ buffer.append(list.get(i) + WRITE_CSV_SEPARATOR);
+ } else {
+ buffer.append(list.get(i));
+ }
+ }
+ return buffer.toString();
+ }
-
++
+ public String getSelectedTarget() {
+ return selectedTarget;
+ }
-
++
+ public void setSelectedTarget(String selectedTarget) {
+ this.selectedTarget = selectedTarget;
+ }
+
+ public boolean isShowInitial() {
+ return showInitial;
+ }
+
+ public void setShowInitial(boolean showInitial) {
+ this.showInitial = showInitial;
+ }
+
+ public boolean isAutoStop() {
+ return autoStop;
+ }
+
+ public void setAutoStop(boolean autoStop) {
+ this.autoStop = autoStop;
+ }
+
+ public List<String> getSelectedChartList() {
+ if (selectedChartList == null) {
+ selectedChartList = new ArrayList<String>();
+ }
+ return selectedChartList;
+ }
-
++
+ public void setSelectedChartList(List<String> selectedChartList) {
+ if (this.selectedChartList != null) {
+ this.selectedChartList.clear();
+ }
+ this.selectedChartList = selectedChartList;
+ }
+
+ public Map<String, TargetData> getTargetListMap() {
+ if (targetListMap == null) {
+ targetListMap = new LinkedHashMap<String, TargetData>();
+ }
+ return targetListMap;
+ }
- DeviceInfo currentDevice = GlobalInformation.getCurrentDeviceInfo();
++
+ public TargetData getConnectedTarget() {
+ // check connected target
+ Map<String, TargetData> map = getTargetListMap();
- IDevice device = currentDevice.getIDevice();
++ DeviceInfo currentDevice = Global.getCurrentDeviceInfo();
+
+ if (currentDevice != null) {
-
++ IDevice device = currentDevice.getIDevice();
+ String profileName = ProfileInfo.getPlatformName(device); // mobile-2.3
+ // device.getPlatformInfo().getProfileName(); // mobile
-
++
+ if (isTarget(profileName)) {
+ return map.get(profileName);
+ }
+ }
-
++
+ return map.get(selectedTarget);
+ }
- } // else : return null
++
+ public TargetData getTarget(String targetName) {
+ Map<String, TargetData> map = getTargetListMap();
+ if (targetName == null) {
+ return map.get(selectedTarget);
+ } else if (isTarget(targetName) == true) {
+ return map.get(targetName);
-
++ } // else : return null
+ return null;
+ }
- Map<String, TargetData> map = getTargetListMap();
++
+ public boolean isTarget(String targetName) {
- Map<String, TargetData> map = getTargetListMap();
++ Map<String, TargetData> map = getTargetListMap();
+ if (map.get(targetName) == null) {
+ return false;
+ }
+ return true;
+ }
+
+ private TargetData getAndCreateTarget(String targetName) {
-
++ Map<String, TargetData> map = getTargetListMap();
+ TargetData target = null;
- map.put(targetName, target);
++
+ if (isTarget(targetName) == false) {
+ target = new TargetData(targetName);
-
++ map.put(targetName, target);
+ } else {
+ target = map.get(targetName);
+ }
+ return target;
+ }
- * @param targetName targetName
++
+ /**
+ * Get page information shown on the screen.
+ *
- * @return The page name list to be shown on the screen.
++ * @param targetName
++ * targetName
+ *
- Map<String, TargetData> map = getTargetListMap();
++ * @return The page name list to be shown on the screen.
+ */
+ public Set<String> getSelectedPageList(String targetName) {
+ String searchTargetName = validateTargetName(targetName);
+ if (isTarget(searchTargetName) == true) {
- * @param targetName targetName
++ Map<String, TargetData> map = getTargetListMap();
+ TargetData target = map.get(searchTargetName);
+ return target.getSelectedPageList();
+ } else {
+ Logger.debug("Does not exist targetName : " + searchTargetName);
+ }
+ return null;
+ }
+
+ /**
+ * Get chart information shown on the screen.
+ *
- * @return The chart name list to be shown on the screen.
++ * @param targetName
++ * targetName
+ *
- Map<String, TargetData> map = getTargetListMap();
++ * @return The chart name list to be shown on the screen.
+ */
+ public Set<String> getSelectedChartList(String targetName) {
+ String searchTargetName = validateTargetName(targetName);
+ if (isTarget(searchTargetName) == true) {
-
++ Map<String, TargetData> map = getTargetListMap();
+ TargetData target = map.get(searchTargetName);
+ return target.getSelectedChartList();
+ } else {
+ Logger.debug("Does not exist targetName : " + searchTargetName);
+ }
+ return null;
+ }
+
+ private String validateTargetName(String targetName) {
+ if (targetName == null) {
+ return selectedTarget;
+ } else {
+ return targetName;
+ }
+ }
-
++
+ public boolean changedFeatures() {
+ // check target
+ if (initTarget.equals(selectedTarget) == false) {
+ return true;
+ }
+
+ // check showInitial
+ if (initShowInitial != showInitial) {
+ return true;
+ }
- Map<String, TargetData> map = getTargetListMap();
++
+ // check autoStop
+ if (initAutoStop != autoStop) {
+ return true;
+ }
+
+ // check template, feature
-
++ Map<String, TargetData> map = getTargetListMap();
+ for (Map.Entry<String, TargetData> entry : map.entrySet()) {
+ TargetData target = entry.getValue();
+ if (target.changedFeatures() == true) {
+ return true;
+ }
+ }
+ return false;
+ }
-
++
+ public void applySettingData() {
+ // write setting file
+ writeSettingDataToFile();
-
++
+ // update init setting data
+ initTarget = selectedTarget;
+ initShowInitial = showInitial;
+ initAutoStop = autoStop;
- Map<String, TargetData> map = getTargetListMap();
++
+ // update init template, feature
-
++ Map<String, TargetData> map = getTargetListMap();
+ for (Map.Entry<String, TargetData> entry : map.entrySet()) {
+ TargetData target = entry.getValue();
+ target.applySettingData();
+ }
+ }
+
+ public void revertSettingData() {
+ // revert setting data
+ selectedTarget = initTarget;
+ showInitial = initShowInitial;
+ autoStop = initAutoStop;
- Map<String, TargetData> map = getTargetListMap();
++
+ // revert template, feature
- if (null == platform || platform.isEmpty()
- || platform.equals(ConfigureLabels.PLATFORM_ETC)) {
++ Map<String, TargetData> map = getTargetListMap();
+ for (Map.Entry<String, TargetData> entry : map.entrySet()) {
+ TargetData target = entry.getValue();
+ target.revertSettingData();
+ }
+ }
+
+ public String getPlatform() {
-
++ if (null == platform || platform.isEmpty() || platform.equals(ConfigureLabels.PLATFORM_ETC)) {
+ return null;
+ } else {
+ return platform;
+ }
+ }
+
+ public long getInternalLogLevel() {
+ return internalLogLevel;
+ }
+
+ public void writeSelectedChartList(List<String> selectedChartList) {
+ setSelectedChartList(selectedChartList);
- writeSettingDataToFile();
++
+ // write setting file
- Map<String, TargetData> map = getTargetListMap();
++ writeSettingDataToFile();
+ }
+
+ public void writeAvailableChartList(String targetName, List<String> availableChartList) {
+ String searchTargetName = validateTargetName(targetName);
+ if (isTarget(searchTargetName) == true) {
-
++ Map<String, TargetData> map = getTargetListMap();
+ TargetData target = map.get(searchTargetName);
+ target.setAvailableChartList(availableChartList);
+ } else {
+ Logger.debug("Does not exist targetName : " + searchTargetName);
+ }
- writeSettingDataToFile();
++
+ // write setting file
-
++ writeSettingDataToFile();
+ }
+
+ public long getSelectedFeatureSwapValue() {
+ long state = 0;
+ TargetData target = SettingDataManager.getInstance().getTarget(null);
+ List<FeatureValueData> featureList = target.getSelectedFeatureList();
-
-
++
+ for (int i = 0; i < featureList.size(); i++) {
+ state |= target.getSelectedFeatureSwapValue(featureList.get(i).getFeatureName());
+ }
+ return state;
+ }
-
- if (target.isSelectedFeature(ConfigureLabels.PERIODIC) == false) {
++
+ public long getConfiguration(DeviceInfo devInfo) {
+ TargetData target = SettingDataManager.getInstance().getConnectedTarget();
+ long state = 0;
+
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_FUNCTION_PROFILING);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_FUNCTION_SAMPLING);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_MEMORY_ALLOCATION);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_FILE);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_THREAD);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_USERINTERFACE);
-
++
++ if (target.isSelectedFeature(ConfigureLabels.PERIODIC) == false) {
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SCREENSHOT);
+ }
-
- if ((target.isSelectedFeature(ConfigureLabels.FEATURE_FILE)
- || (target.isSelectedFeature(ConfigureLabels.FEATURE_SYSCALL_FILE)))) {
++
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_USER_EVENT);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_RECORDING);
+
+ if (DACommunicator.isSWAPVersion(devInfo)) {
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSCALL_IPC);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSCALL_PROCESS);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSCALL_SIGNAL);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSCALL_NETWORK);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSCALL_DESC);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_CONTEXT_SWITCH);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_NETWORK);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_OPENGL);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.INCLUDE_INSIDE_CALL_MEMORY);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.INCLUDE_INSIDE_CALL_THREAD);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.INCLUDE_INSIDE_CALL_FILE);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.INCLUDE_INSIDE_CALL_UI);
-
++
++ if ((target.isSelectedFeature(ConfigureLabels.FEATURE_FILE) || (target
++ .isSelectedFeature(ConfigureLabels.FEATURE_SYSCALL_FILE)))) {
+ state |= AnalyzerConstants.FEATURE_SYSCALL_FILE;
+ }
+ }
+ return state;
+ }
- state |= target.getSelectedFeatureSwapValue(ConfigureLabels.INCLUDE_INSIDE_CALL_NETWORK);
++
+ public long getPreConfiguration(DeviceInfo devInfo) {
+ TargetData target = SettingDataManager.getInstance().getConnectedTarget();
+ long state = 0;
+ if (DACommunicator.isSWAPVersion(devInfo)) {
-// state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_FD);
-// state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_THREAD);
++ state |= target
++ .getSelectedFeatureSwapValue(ConfigureLabels.INCLUDE_INSIDE_CALL_NETWORK);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.INCLUDE_INSIDE_OPENGL);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_CPU);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_PROCESSES);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_MEMORY);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_DISK);
-
++ // state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_FD);
++ // state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_THREAD);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_NETWORK);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_DEVICE);
+ state |= target.getSelectedFeatureSwapValue(ConfigureLabels.FEATURE_SYSTEM_ENERGY);
++
+ if (target.isSelectedFeature(ConfigureLabels.FEATURE_THREAD)) {
+ state |= AnalyzerConstants.SYSTEM_THREAD_LOAD;
+ }
+ }
+ return state;
+ }
+ }
--- /dev/null
-import org.tizen.dynamicanalyzer.common.GlobalInformation;
+ /*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Heeyoung Hwang <heeyoung1008.hwang@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+ package org.tizen.dynamicanalyzer.ui.toolbar.setting;
+
+ import java.util.ArrayList;
+ import java.util.List;
+ import java.util.Set;
+
+ import org.eclipse.nebula.widgets.grid.Grid;
+ import org.eclipse.nebula.widgets.grid.GridItem;
-
++import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
++import org.tizen.dynamicanalyzer.common.Global;
+ import org.tizen.dynamicanalyzer.common.HostResult;
+ import org.tizen.dynamicanalyzer.communicator.DACommunicator;
+ import org.tizen.dynamicanalyzer.constant.CommonConstants;
+ import org.tizen.dynamicanalyzer.nl.ConfigureLabels;
+ import org.tizen.dynamicanalyzer.ui.page.BaseView;
+ import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineChartManager;
+ import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
+ import org.tizen.dynamicanalyzer.widgets.da.base.DAMessageBox;
+
+ public class SettingDialogManager {
+
+ private static SettingDialogManager instance = null;
+
+ private DAMessageBox configDlg = null;
+ private FeatureDialog featureDlg = null;
-
++
+ public synchronized static SettingDialogManager getInstance() {
+ if (instance == null) {
+ instance = new SettingDialogManager();
+ }
+ return instance;
+ }
-
++
+ public void setConfigDlg(DAMessageBox configDlg) {
+ this.configDlg = configDlg;
+ }
-
++
+ public DAMessageBox getConfigDlg() {
+ return configDlg;
+ }
- public boolean applySwapValue() {
++
+ public FeatureDialog getFeatureDlg() {
+ return featureDlg;
+ }
+
+ public void setFeatureDlg(FeatureDialog featureDlg) {
+ this.featureDlg = featureDlg;
+ }
+
- if (null != GlobalInformation.getCurrentDeviceInfo()) {
- HostResult result = DACommunicator.sendRuntimeMessage(
- DACommunicator.MSG_TYPE_CONFIG, null);
++ public boolean applySwapValue() {
+ boolean ret = true;
- GlobalInformation.getCurrentDeviceInfo().setConfigSuccess(false);
++ if (null != Global.getCurrentDeviceInfo()) {
++ HostResult result = DACommunicator.sendRuntimeMessage(DACommunicator.MSG_TYPE_CONFIG,
++ null);
+ // check result
+ if (!result.equals(HostResult.SUCCESS)) {
- GlobalInformation.getCurrentDeviceInfo().setConfigSuccess(true);
++ Global.getCurrentDeviceInfo().setConfigSuccess(false);
+ ret = false;
+ } else {
-
- public void updateFeatureButtonStatus(Boolean enable, Grid table) {
++ Global.getCurrentDeviceInfo().setConfigSuccess(true);
+ }
+ }
+ return ret;
+ }
-
++
++ public void updateFeatureButtonStatus(Boolean enable, Grid table) {
+ if (changedFeaturesFromTableItemsList(table) == true) {
+ featureDlg.enableButteon();
+ } else {
+ featureDlg.diableButteon();
+ }
-
++
+ if (null != enable) {
+ if (enable) {
+ featureDlg.enableButteon();
+ } else {
+ featureDlg.diableButteon();
+ }
+ }
+ }
- // change button status
++
+ public void updateSaveButtonStatus(Boolean enable) {
- }
++ // change button status
+ if (SettingDataManager.getInstance().changedFeatures() == true) {
+ if (getConfigDlg() instanceof SettingDialog) {
+ SettingDialog dlg = (SettingDialog) getConfigDlg();
+ dlg.editableButteon();
+ } else {
+ WelcomeDialog dlg = (WelcomeDialog) getConfigDlg();
+ dlg.editableButteon();
-
++ }
+ } else {
+ if (getConfigDlg() instanceof SettingDialog) {
+ SettingDialog dlg = (SettingDialog) getConfigDlg();
+ dlg.applicableButteon();
+ } else {
+ WelcomeDialog dlg = (WelcomeDialog) getConfigDlg();
+ dlg.applicableButteon();
+ }
+ }
+ }
-
++
+ public void setFeaturesValueFromTableItemsList(Grid table) {
+ TargetData target = SettingDataManager.getInstance().getTarget(null);
+ List<FeatureValueData> list = new ArrayList<FeatureValueData>();
+ FeatureValueData featureValue = null;
-
++
+ for (int i = 0; i < table.getItemCount(); i++) {
+ String featureName = table.getItem(i).getText(0);
+ String optionText = table.getItem(i).getText(1);
- || (optionText.contains(FeatureDialog.ITEM_PART_CHECKED))) {
-
++
+ FeatureData feature = target.getAvailableFeature(featureName);
+ if ((optionText.contains(FeatureDialog.ITEM_ALL_CHECKED))
- } else { // main, sub fearue
++ || (optionText.contains(FeatureDialog.ITEM_PART_CHECKED))) {
++
+ // check detail feature
+ if (feature.getFeatureType() == FeatureData.FEATURE_TYPE_DETAIL) {
+ featureValue = addDetailFeature(table.getItem(i), target);
-
++ } else { // main, sub fearue
+ featureValue = new FeatureValueData();
+ featureValue.setFeatureName(featureName);
+ }
+ list.add(featureValue);
+ }
+ }
+ target.setSelectedFeatureList(list);
+ }
- * @param table feature table
++
+ /**
+ * Make sure that the feature has changed in the table.
+ *
- * @return Whether the change of feature
++ * @param table
++ * feature table
+ *
-
++ * @return Whether the change of feature
+ */
+ public boolean changedFeaturesFromTableItemsList(Grid table) {
+ TargetData target = SettingDataManager.getInstance().getTarget(null);
+ int count = 0;
- || (optionText.contains(FeatureDialog.ITEM_PART_CHECKED))) {
++
+ for (int i = 0; i < table.getItemCount(); i++) {
+ String featureName = table.getItem(i).getText(0);
+ String optionText = table.getItem(i).getText(1);
+
+ FeatureData feature = target.getAvailableFeature(featureName);
+ if ((optionText.contains(FeatureDialog.ITEM_ALL_CHECKED))
-
++ || (optionText.contains(FeatureDialog.ITEM_PART_CHECKED))) {
+ count++;
- }
- } else { // main, sub fearue
++
+ // check detail feature
+ if (feature.getFeatureType() == FeatureData.FEATURE_TYPE_DETAIL) {
+ if (changedDetailFeature(table.getItem(i), target) == true) {
+ return true;
-
++ }
++ } else { // main, sub fearue
+ if (target.isSelectedFeature(featureName) == false) {
+ return true;
+ }
+ }
+ }
+ }
-
++
+ if (target.getSelectedFeatureList().size() != count) {
+ return true;
+ }
+ return false;
+ }
- String featureName = item.getText(0);
-
- if ((ConfigureLabels.SYSTEM_INFOMATION_SAMPLING_PERIODIC.equals(featureName))
++
+ private FeatureValueData addDetailFeature(GridItem item, TargetData target) {
+ FeatureValueData featureValue = null;
- featureValue.setValue(1);
++ String featureName = item.getText(0);
++
++ if ((ConfigureLabels.SYSTEM_INFOMATION_SAMPLING_PERIODIC.equals(featureName))
+ || (ConfigureLabels.FUNCTION_PROFILING_SAMPLING_PERIODIC.equals(featureName))) {
+ int tableValue = Integer.parseInt(getOptionText(item, ConfigureLabels.SAMPLING));
+ featureValue = new FeatureValueData();
+ featureValue.setFeatureName(featureName);
+ featureValue.setValue(tableValue);
+ } else if (ConfigureLabels.SNAPSHOT_PERIODIC_AUTO.equals(featureName)) {
+ int tableAutoValue = Integer.parseInt(getOptionText(item, ConfigureLabels.AUTO));
+ if (tableAutoValue == 1) {
+ featureValue = new FeatureValueData();
+ featureValue.setFeatureName(featureName);
- featureValue.setValue(tableValue);
++ featureValue.setValue(1);
+ } else {
+ int tableValue = Integer.parseInt(getOptionText(item, ConfigureLabels.SAMPLING));
+ featureValue = new FeatureValueData();
+ featureValue.setFeatureName(ConfigureLabels.PERIODIC);
-
++ featureValue.setValue(tableValue);
+ }
+ }
+ return featureValue;
+ }
- String featureName = item.getText(0);
-
- if ((ConfigureLabels.SYSTEM_INFOMATION_SAMPLING_PERIODIC.equals(featureName))
++
+ private boolean changedDetailFeature(GridItem item, TargetData target) {
- int tableSamplingValue = Integer.parseInt(getOptionText(item, ConfigureLabels.SAMPLING));
++ String featureName = item.getText(0);
++
++ if ((ConfigureLabels.SYSTEM_INFOMATION_SAMPLING_PERIODIC.equals(featureName))
+ || (ConfigureLabels.FUNCTION_PROFILING_SAMPLING_PERIODIC.equals(featureName))) {
+ int value = target.getSelectedFeatureValue(featureName);
+ int tableValue = Integer.parseInt(getOptionText(item, ConfigureLabels.SAMPLING));
+ if (value != tableValue) {
+ return true;
+ }
+ } else if (ConfigureLabels.SNAPSHOT_PERIODIC_AUTO.equals(featureName)) {
+ int tableAutoValue = Integer.parseInt(getOptionText(item, ConfigureLabels.AUTO));
+ if (tableAutoValue == 1) {
+ if (target.isSelectedFeature(ConfigureLabels.SNAPSHOT_PERIODIC_AUTO) == false) {
+ return true;
+ }
+ } else {
+ if (target.isSelectedFeature(ConfigureLabels.PERIODIC) == false) {
+ return true;
+ } else {
+ int value = target.getSelectedFeatureValue(ConfigureLabels.PERIODIC);
-
++ int tableSamplingValue = Integer.parseInt(getOptionText(item,
++ ConfigureLabels.SAMPLING));
+ if (value != tableSamplingValue) {
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
- String[] optionList2 = optionList[1]
- .split(CommonConstants.COMMA);
++
+ private String getOptionText(GridItem item, String optionName) {
+ String value = null;
+ if (item.getText(1).contains(optionName)) {
+ String[] optionList = item.getText(1).split(optionName);
+ if (optionList.length > 1) {
+ if (optionList[1].contains(CommonConstants.COMMA)) {
-
++ String[] optionList2 = optionList[1].split(CommonConstants.COMMA);
+ value = optionList2[0];
+ } else {
+ value = optionList[1];
+ }
+ }
+ }
+ return value;
+ }
- tabViewList.add(CommonConstants.PAGE_TIME_LINE); // default : timeline tab
-
++
+ /**
+ * create tab pages
+ */
+ public void updateTabViewPage() {
+ TargetData target = SettingDataManager.getInstance().getConnectedTarget();
+ Set<String> selectedPageList = target.getSelectedPageList();
+ List<Integer> tabViewList = new ArrayList<Integer>();
- tabViewList.add(CommonConstants.PAGE_THREAD);
++ tabViewList.add(AnalyzerConstants.PAGE_TIME_LINE); // default : timeline tab
++
+ // thread tab
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_THREAD)) {
- tabViewList.add(CommonConstants.PAGE_NETWORK);
++ tabViewList.add(AnalyzerConstants.PAGE_THREAD);
+ } // else nothing
+
+ // network tab
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_NETWORK)) {
- tabViewList.add(CommonConstants.PAGE_FILE);
++ tabViewList.add(AnalyzerConstants.PAGE_NETWORK);
+ } // else nothing
+
+ // file tab
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_FILE)) {
-
++ tabViewList.add(AnalyzerConstants.PAGE_FILE);
+ } // else nothing
- tabViewList.add(CommonConstants.PAGE_GRAPHICS);
++
+ // openGL tab
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_OPENGL)) {
- tabViewList.add(CommonConstants.PAGE_KERNEL);
++ tabViewList.add(AnalyzerConstants.PAGE_GRAPHICS);
+ } // else nothing
+
+ // kernel tab
+ if (selectedPageList.contains(ConfigureLabels.PAGE_NAME_KERNEL)) {
- tabViewList.add(CommonConstants.PAGE_SUMMARY); // default : summary tab
++ tabViewList.add(AnalyzerConstants.PAGE_KERNEL);
+ } // else nothing
+
-
++ tabViewList.add(AnalyzerConstants.PAGE_SUMMARY); // default : summary tab
+
+ BaseView bv = (BaseView) WorkbenchUtil.getViewPart(BaseView.ID);
+ bv.addTabViewPage(tabViewList);
+ }
+
+ /**
+ * update chart list
+ */
+ public void updateChartList() {
+ TargetData target = SettingDataManager.getInstance().getConnectedTarget();
+ Set<String> selectedChartList = target.getSelectedChartList();
+ TimelineChartManager.getInstance().loadSelectedChartList(selectedChartList);
++
+ // TODO : selectedChartList remove?
+ if (selectedChartList.size() > 0) {
+ List<String> list = SettingDataManager.getInstance().getSelectedChartList();
+ if (list.size() > 0) {
+ list.clear();
+ }
+ list.addAll(selectedChartList);
+ }
+ }
+ }
projects / sdk / tools / dynamic-analyzer.git / commitdiff