import org.tizen.dynamicanalyzer.ui.info.screenshot.ScreenshotTimer;
import org.tizen.dynamicanalyzer.ui.page.MenuBar;
import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer;
-import org.tizen.dynamicanalyzer.ui.timeline.dlog.DADlogReceiver;
+import org.tizen.dynamicanalyzer.ui.timeline.dlog.DLogDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.Toolbar;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
private void startDlog(){
Thread DlogThread = new Thread(new Runnable() {
public void run() {
- DADlogReceiver dlogRecv = new DADlogReceiver();
- dlogRecv.startDlog();
+ DLogDataManager.getInstance().startDlog();
}
});
DlogThread.start();
import org.tizen.dynamicanalyzer.ui.page.BaseView;
import org.tizen.dynamicanalyzer.ui.page.MenuBar;
import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer;
-import org.tizen.dynamicanalyzer.ui.timeline.dlog.DADlogReceiver;
+import org.tizen.dynamicanalyzer.ui.timeline.dlog.DLogDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.Toolbar;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
private DAResult error;
private boolean stopFromTarget = false;
private Boolean stopThreadCompleted = false;
- private DADlogReceiver dlogRecv = new DADlogReceiver();
public StopTraceManager(DAResult err, boolean stopFromTarget) {
this.error = err;
this.stopFromTarget = stopFromTarget;
// change summary UI
// change to summary page
UIAction.applyStopTraceUI();
- dlogRecv.stopDlog();
+ DLogDataManager.getInstance().stopDlog();
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
private static final String PROFILE_START_TIME = "profilingStartTime";
private static final String PAGE_TAB_LIST = "pageTabList";
private static final String TIMELINE_CHART_LIST = "timelineChartList";
+
+ private static final String MEMPS_DATA_AVAILABLE = "availableMemps";
+ private static final String DA_START_TIME = "daStartTime";
private ProjectVersion version = ProjectVersion.VERSION_UNKNOWN;
private String protocolVersion = null;
private int seqRotation = 0;
private int activeProcessCount = 0;
+
+ private boolean availableMemps = false;
+ private String daStartTime = "";
+ private boolean isSavedData = false;
static {
// register DB table
writer.write(CommonConstants.NEW_LINE);
writer.write(CREATE_TIME + CommonConstants.EQUAL + getCreateTime());
writer.write(CommonConstants.NEW_LINE);
- writer.write(TOTAL_STOP_TIME + CommonConstants.EQUAL + getTotalStopTime());
+ writer.write(TOTAL_STOP_TIME + CommonConstants.EQUAL + getTotalStopTime());
+ writer.write(CommonConstants.NEW_LINE);
+ writer.write(DA_START_TIME + CommonConstants.EQUAL + getDAStartTime());
+ writer.write(CommonConstants.NEW_LINE);
+ writer.write(MEMPS_DATA_AVAILABLE + CommonConstants.EQUAL + (getMempsAvailable() ? "true" : "false"));
writer.write(CommonConstants.NEW_LINE);
writer.write(REPLAY_STOP_TIME + CommonConstants.EQUAL + getReplayStopTime());
writer.write(CommonConstants.NEW_LINE);
pageTabList = val.split(CommonConstants.COMMA);
} else if (infoKey.equals(TIMELINE_CHART_LIST)) {
timelineChartList = val.split(CommonConstants.COMMA);
+ } else if (infoKey.equals(MEMPS_DATA_AVAILABLE)) {
+ if(val.equals("true")) {
+ setMempsAvailable(true);
+ }
+ else {
+ setMempsAvailable(false);
+ }
+ } else if (infoKey.equals(DA_START_TIME)) {
+ setDAStartTime(val);
}
}
} else {
timelineChartList = chartList.toArray(new String[0]);
}
+
+ public void setMempsAvailable(boolean available) {
+ this.availableMemps = available;
+ }
+
+ public boolean getMempsAvailable() {
+ return this.availableMemps;
+ }
+
+ public void setDAStartTime(String timestring) {
+ this.daStartTime = timestring;
+ }
+
+ public String getDAStartTime() {
+ return this.daStartTime;
+ }
+
+ public void setSavedProject (boolean save) {
+ this.isSavedData = save;
+ }
+
+ public boolean isSaveProject() {
+ return this.isSavedData;
+ }
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Dongkye Lee <dongkyu6.lee@samsung.com>
+ * Jaeyong Lee <jae-yong.lee@@samsung.com>
+ * Gihun Chang <gihun.chang@@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.
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.page;
+
+import java.io.File;
+import java.util.List;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.DAResult;
+import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
+import org.tizen.dynamicanalyzer.database.compatible.DBConverter;
+import org.tizen.dynamicanalyzer.handlers.CommandAction;
+import org.tizen.dynamicanalyzer.handlers.CommonAction;
+import org.tizen.dynamicanalyzer.handlers.UIAction;
+import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
+import org.tizen.dynamicanalyzer.project.BinaryInfo;
+import org.tizen.dynamicanalyzer.project.Project;
+import org.tizen.dynamicanalyzer.resources.ImageResources;
+import org.tizen.dynamicanalyzer.setting.UILayoutDataManager;
+import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
+import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
+import org.tizen.dynamicanalyzer.ui.range.RangePage;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingChildData;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingChildDataDBTable;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingData;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingDataDBTable;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.WebProfileDataMaker;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.WebProfilingData;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.WebProfilingDataDBTable;
+import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
+import org.tizen.dynamicanalyzer.ui.toolbar.Toolbar;
+import org.tizen.dynamicanalyzer.ui.userinterface.UIDataManager;
+import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
+import org.tizen.dynamicanalyzer.widgets.da.base.DADialog;
+import org.tizen.dynamicanalyzer.widgets.da.base.ProgressDialog;
+import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
+import org.tizen.dynamicanalyzer.workbench.LayoutManager;
+
+public class LoadDAFile implements Runnable {
+ private ProgressDialog progressDialog;
+ private String filepath = "";
+
+ public LoadDAFile() {
+
+ }
+
+ @Override
+ public void run() {
+ //startProgress();
+ boolean ret = false;
+ String decompresspath = CommandAction.loadFromZip(this.filepath);
+ if (decompresspath != null && !decompresspath.isEmpty()) {
+ Project project = Project.getProjectFromFile(decompresspath);
+ project.setSavedProject(true);
+ if (project != null) {
+ Global.setProject(project);
+ if (openTraceFile(decompresspath)) {
+ ret = true;
+ Logger.debug("Open File Success : " + this.filepath);
+ } else {
+ Logger.debug("Open File Fail : " + this.filepath);
+ }
+ }
+ }
+
+ //stopProgress(ret);
+ }
+
+ public void setZipFilePath(String path) {
+ this.filepath = path;
+ }
+
+ private boolean openTraceFile(String tracePath) {
+
+ final Project project = Global.getProject();
+
+ // establish db connection with new path
+ SqlConnectionManager.closeConnection();
+ SqlConnectionManager
+ .establishConnection(project.getSavePath() + File.separator + AnalyzerConstants.DATABASE_NAME);
+
+ // convert save file for compatible database
+ DBConverter converter = new DBConverter(project.getVersion());
+ if (!converter.convert()) {
+ // failed to convert for compatible database
+ UIAction.showWarning(AnalyzerLabels.OPEN_TRACE_PROGRESS_INVALID);
+ CommonAction.clear();
+ return false;
+ } else {
+ // converting is succeeded
+ // change version of save file to current version
+ project.upgrade();
+ }
+
+ boolean bsuccess = project.openDetail();
+ if (!bsuccess) {
+ UIAction.showWarning(AnalyzerLabels.OPEN_TRACE_PROGRESS_VERSION_INVALID_REMOVE);
+ CommonAction.clear();
+ return false;
+ }
+
+ if (loadProfilingData(project) && loadProfilingChildData() && loadWebProfilingData()) {
+
+ } else {
+ UIAction.showWarning(AnalyzerLabels.OPEN_TRACE_PROGRESS_INVALID_REMOVE);
+ CommonAction.clear();
+ return false;
+ }
+
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ Toolbar.INSTANCE.setTime(project.getTotalStopTime());
+ Toolbar.INSTANCE.setAllControlState(true);
+ }
+ });
+
+ // change tab list and page to be shown
+ UIAction.setPages(project.getPageTabList());
+
+ // change chart list in timeline page
+ UIAction.setCharts(project.getTimelineChartList());
+
+ // change page
+ if (RangeDataManager.getInstance().isBeingAnalyzed()) {
+ DAPageComposite page = AnalyzerManager.getCurrentPage();
+ if (page instanceof RangePage) {
+ AnalyzerUtil.changePage(TimelinePage.pageID);
+ }
+ }
+
+ // set dirty of UI layout
+ UILayoutDataManager.INSTANCE.setDirty(true);
+
+ // open for each PageDataManager
+ DataManagerRegistry.openData();
+
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ UIAction.applyWebProfilingUI(Global.getProject().isWebApplication());
+
+ DAPageComposite page = AnalyzerManager.getCurrentPage();
+ page.updateView();
+ }
+ });
+
+ return true;
+ }
+
+ private boolean loadProfilingData(Project project) {
+ boolean isSuccess = true;
+ List<List<Object>> profilingDatas = FunctionUsageProfiler.getInstance().getProfilingDataTable()
+ .getProfilingDataFromDB();
+ if (null == profilingDatas) {
+ Logger.debug("failed - loadProfilingData");
+ isSuccess = false;
+ } else {
+ for (int i = 0; i < profilingDatas.size(); i++) {
+ List<Object> profilingData = profilingDatas.get(i);
+ int pid = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.PID.index);
+ // possibility of extensions - network, efl, db, etc...
+ ProfileDataMaker profiler = FunctionUsageProfiler.getInstance().getProfileDataMakerByPid(pid);
+ int profilingDataID = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.PROFILING_DATA_ID.index);
+ byte type = (Byte) profilingData.get(ProfilingDataDBTable.COLUMN.TYPE.index);
+ int exCount = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.EXCLUSIVE_COUNT.index);
+ int inCount = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.INCLUSIVE_COUNT.index);
+ int callCount = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.CALL_COUNT.index);
+ long inElapsedTime = (Long) profilingData
+ .get(ProfilingDataDBTable.COLUMN.INCLUSIVE_EXECUTION_TIME.index);
+ long exElapsedTime = (Long) profilingData
+ .get(ProfilingDataDBTable.COLUMN.EXCLUSIVE_EXECUTION_TIME.index);
+ String name;
+ ProfilingData fupData = null;
+ int binaryId;
+ BinaryInfo bInfo = null;
+ switch (type) {
+ case ProfilingData.TYPE_APPLICATION:
+ case ProfilingData.TYPE_DEPENDENTLIBRARY:
+ case ProfilingData.TYPE_LIBRARY:
+ binaryId = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.BINARY_ID.index);
+ bInfo = project.getDeviceStatusInfo().getBinaryInfo(binaryId);
+ name = bInfo.getTargetBinaryPath();
+ fupData = new ProfilingData(profilingDataID, name, exCount, inCount, callCount, inElapsedTime,
+ exElapsedTime, profiler);
+ break;
+ case ProfilingData.TYPE_FUNCTION:
+ int functionId = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.FUNCTION_ID.index);
+ name = project.getFunctionName(functionId);
+ fupData = new ProfilingData(profilingDataID, name, exCount, inCount, callCount, inElapsedTime,
+ exElapsedTime, profiler);
+ break;
+ default: // never goes here
+ Logger.error("invalid profiling data type");
+ break;
+ }
+
+ if (null == fupData) {
+ isSuccess = false;
+ } else {
+ if (type == ProfilingData.TYPE_APPLICATION) {
+ profiler.setAppBin(fupData);
+ } else if (type == ProfilingData.TYPE_DEPENDENTLIBRARY) {
+ profiler.setDependentLib(fupData);
+ }
+
+ profiler.getProfilingDataMap().put(profilingDataID, fupData);
+ UIDataManager.getInstance().getfunctionProfilingDataChecker().addProfilingData(fupData);
+ // restore total sample count
+ profiler.setTotalSampleCount(profiler.getTotalSampleCount() + fupData.getExCount());
+ }
+ }
+ }
+ return isSuccess;
+ }
+
+ private boolean loadProfilingChildData() {
+ boolean isSuccess = true;
+ List<List<Object>> profilingChilds = FunctionUsageProfiler.getInstance().getProfilingChildDataTable()
+ .getProfilingChildDataFromDB();
+ if (null == profilingChilds) {
+ Logger.debug("failed - loadProfilingChildData");
+ isSuccess = false;
+ } else {
+ int size = profilingChilds.size();
+ for (int i = 0; i < size; i++) {
+ List<Object> data = profilingChilds.get(i);
+ int parentID = (Integer) data.get(ProfilingChildDataDBTable.COLUMN.PROFILING_DATA_ID.index);
+ int pid = (Integer) data.get(ProfilingChildDataDBTable.COLUMN.PID.index);
+
+ @SuppressWarnings("unchecked")
+ List<Integer> childSeqList = (List<Integer>) data
+ .get(ProfilingChildDataDBTable.COLUMN.CHILD_SEQUENCE_ARRAY.index);
+
+ ProfileDataMaker profiler = FunctionUsageProfiler.getInstance().getProfileDataMakerByPid(pid);
+ ProfilingData parent = profiler.getProfilingDataMap().get(parentID);
+ ProfilingChildData child = parent.getChildData();
+ child.getChildren().addAll(childSeqList);
+ }
+ }
+ return isSuccess;
+ }
+
+ private boolean loadWebProfilingData() {
+ boolean isSuccess = true;
+ List<List<Object>> profilingDatas = FunctionUsageProfiler.getInstance().getWebProfilingDataTable()
+ .getWebProfilingDataFromDB();
+ if (null == profilingDatas) {
+ Logger.debug("failed - loadWebProfilingData");
+ isSuccess = false;
+ } else {
+ for (int i = 0; i < profilingDatas.size(); i++) {
+ List<Object> profilingData = profilingDatas.get(i);
+
+ int profilingDataID = (Integer) profilingData
+ .get(WebProfilingDataDBTable.COLUMN.PROFILING_DATA_ID.getIndex());
+ int pid = (Integer) profilingData.get(WebProfilingDataDBTable.COLUMN.PID.getIndex());
+ int functionLineNumber = (Integer) profilingData
+ .get(WebProfilingDataDBTable.COLUMN.FUNCTION_LINE_NUMBER.getIndex());
+ String functionName = (String) profilingData
+ .get(WebProfilingDataDBTable.COLUMN.FUNCTION_NAME.getIndex());
+ String functionURL = (String) profilingData.get(WebProfilingDataDBTable.COLUMN.FUNCTION_URL.getIndex());
+ int callCount = (Integer) profilingData.get(WebProfilingDataDBTable.COLUMN.CALL_COUNT.getIndex());
+ long inElapsedTime = (Long) profilingData
+ .get(WebProfilingDataDBTable.COLUMN.INCLUSIVE_EXECUTION_TIME.getIndex());
+ long exElapsedTime = (Long) profilingData
+ .get(WebProfilingDataDBTable.COLUMN.EXCLUSIVE_EXECUTION_TIME.getIndex());
+
+ @SuppressWarnings("unchecked")
+ List<Integer> childSeqList = (List<Integer>) profilingData
+ .get(WebProfilingDataDBTable.COLUMN.CHILD_SEQUENCE_ARRAY.getIndex());
+
+ // create WebProfilingData
+ WebProfilingData fupData = new WebProfilingData(profilingDataID, functionLineNumber, functionName,
+ functionURL, callCount, inElapsedTime, exElapsedTime, childSeqList);
+
+ // get WebProfileDataMaker
+ WebProfileDataMaker profiler = FunctionUsageProfiler.getInstance().getWebProfileDataMakerByPid(pid);
+
+ // set WebProfilingData
+ if (functionName.equals(FunctionUsageProfiler.APPLICATION)) {
+ profiler.setAppBin(fupData);
+ }
+ profiler.webProfilingDataMap().put(profilingDataID, fupData);
+ }
+ }
+ return isSuccess;
+ }
+
+ private void startProgress() {
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
+ progressDialog = new ProgressDialog(shell, LayoutManager.getBaseComposite());
+ progressDialog.setProgressStyle(ProgressDialog.PROGRESS_STYLE_INDETERMINATE);
+ progressDialog.setProgressMessage("Loading saved file...");
+ progressDialog.setProgressInfo(AnalyzerLabels.DLG_PLEASE_WAIT);
+ progressDialog.setCancelListener(new SelectionListener() {
+ @Override
+ public void widgetDefaultSelected(SelectionEvent arg0) {
+
+ }
+
+ @Override
+ public void widgetSelected(SelectionEvent arg0) {
+ cancelProgress();
+ }
+ });
+
+ progressDialog.open();
+ }
+ });
+ }
+
+ public void stopProgress(final boolean isSuccess) {
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ if (progressDialog != null) {
+ progressDialog.close();
+ progressDialog = null;
+ }
+ if (isSuccess) {
+
+ } else {
+ Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
+ DADialog dialog = new DADialog(shell, SWT.NONE);
+ dialog.setIcon(ImageResources.DIALOG_ERROR_ICON);
+ dialog.setMessage("Failed loading zip file.");
+ dialog.setDialog(false);
+ dialog.open();
+ }
+ }
+ });
+ }
+
+ private void cancelProgress() {
+ try {
+ //DAResult result = DACommunicator.cancelRequestUIHierarchy();
+ DAResult result = DAResult.SUCCESS;
+ if (result.isSuccess() != false) {
+ Logger.warning(result);
+ }
+ } catch (Exception e) {
+ Logger.exception(e);
+ }
+
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ if (progressDialog != null) {
+ progressDialog.close();
+ progressDialog = null;
+ }
+ }
+ });
+ }
+}
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineChartManager;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineChartView;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineTableView;
+import org.tizen.dynamicanalyzer.ui.timeline.dlog.DLogDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.replay.data.ReplayDataManager;
import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DATabComposite;
DataManagerRegistry.registerPageDataManager(InteractiveDataManager.getInstance());
DataManagerRegistry.registerPageDataManager(ScreenshotDataManager.getInstance());
DataManagerRegistry.registerPageDataManager(MemoryDataManager.getInstance());
+ DataManagerRegistry.registerPageDataManager(DLogDataManager.getInstance());
}
public TimelineChartView getTimelineChartView() {
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.common.Global;
-import org.tizen.dynamicanalyzer.model.FilterProperty;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.nl.TimelinePageLabels;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
+++ /dev/null
-package org.tizen.dynamicanalyzer.ui.timeline.dlog;\r
-\r
-import java.text.DateFormat;\r
-import java.text.ParseException;\r
-import java.text.SimpleDateFormat;\r
-import java.util.ArrayList;\r
-import java.util.Date;\r
-import java.util.List;\r
-import java.util.regex.Pattern;\r
-import org.tizen.dynamicanalyzer.common.Global;\r
-import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;\r
-import org.tizen.dynamicanalyzer.communicator.DeviceInfo;\r
-import org.tizen.sdblib.receiver.MultiLineReceiver;\r
-import org.tizen.sdblib.util.StringUtil;\r
-\r
-public class DADlogReceiver {\r
- \r
-\r
- static List<String> Dlogs = new ArrayList<String>();\r
- \r
- private static final Pattern pattern = Pattern.compile("\\d{2}-\\d{2}\\s(\\d{2}:\\d{2}:\\d{2}\\.?\\d*)\\+?\\d*\\s+" //time\r
- + "(\\d+)\\s+" //pid\r
- + "(\\d+)\\s+" //tid\r
- + "(V|D|I|W|E|F)\\s+" //level\r
- + "(\\S+)\\s*\\:\\s+" //tag\r
- + "(.*)"); //message\r
- \r
- static boolean start = false;\r
- static boolean dlogKill = false;\r
- static String[] daStartTime = null;\r
- public DADlogReceiver() {\r
- // TODO Auto-generated constructor stub\r
- }\r
-\r
- public boolean startDlog(){\r
- \r
- Pattern timeregex = Pattern.compile("\\S+\\s+" //day\r
- + "\\S+\\s+" //month\r
- + "\\d+\\s+" //date\r
- + "(\\d{2}\\:\\d{2}\\:\\d{2})\\s+" //hour:min:sec\r
- + ".*"); //year\r
- \r
- DeviceInfo curDev = Global.getCurrentDeviceInfo();\r
- \r
- Dlogs.clear();\r
- dlogKill = false;\r
- \r
- \r
- if (curDev == null) {\r
- return false;\r
- }\r
-\r
- CommunicatorUtils.execShellCommand(curDev.getIDevice(),\r
- "date", new MultiLineReceiver() {\r
- @Override\r
- public void processNewLines(String[] appLines) {\r
- for (int i = 0; i < appLines.length; i++) {\r
- daStartTime = appLines;\r
- }\r
- }\r
- });\r
- \r
- String[] TmpdaStartTime = daStartTime;\r
- daStartTime = StringUtil.split(TmpdaStartTime[0], timeregex);\r
-\r
- CommunicatorUtils.execShellCommand(curDev.getIDevice(),\r
- "/usr/bin/dlogutil -c");\r
- \r
- CommunicatorUtils.execShellCommand(curDev.getIDevice(),\r
- "/usr/bin/dlogutil -v threadtime", new MultiLineReceiver() {\r
- @Override\r
- public void processNewLines(String[] appLines) {\r
- start = true;\r
- for (int i = 0; i < appLines.length; i++) {\r
- if(dlogKill){\r
- break;\r
- }\r
- /* Dlog don't show swap_start always...\r
- if(appLines[i].contains("swap_start")){\r
- daStartTime = StringUtil.split(appLines[i], StartTimepattern);\r
- }\r
- */\r
- Dlogs.add(appLines[i]);\r
- //System.out.println(appLines[i]);\r
- }\r
- }\r
- });\r
- \r
- return true;\r
- }\r
- \r
- public void stopDlog(){\r
- dlogKill = true;\r
- }\r
- public List<String> getDlogs(){\r
- return Dlogs;\r
- }\r
- \r
- public List<DADlogData> parserDlogs(){\r
- \r
- List<DADlogData> dlogList = new ArrayList<DADlogData>();\r
- \r
- for (int i=0;i<Dlogs.size();i++) {\r
- // ignore empty line.\r
- // check if the line is header line.\r
- String[] matches = StringUtil.split(Dlogs.get(i), pattern);\r
- if(matches == null) continue;\r
- DADlogData dlogData = new DADlogData();\r
- \r
- \r
- DateFormat formatter = new SimpleDateFormat("hh:mm:ss.SSS");\r
- DateFormat formatter2 = new SimpleDateFormat("hh:mm:ss");\r
- try {\r
- Date date = formatter.parse(matches[0]);\r
- Date DAdate = formatter2.parse(daStartTime[0]);\r
- dlogData.setSyncTime(DAdate);\r
- \r
- int compare = date.compareTo(DAdate);\r
- \r
- if(compare < 0){\r
- continue;\r
- }\r
- else{\r
- long diffTime = date.getTime()*1000 - DAdate.getTime()*1000;\r
- \r
- //dlogData.setTime(matches[0]);\r
- dlogData.setTime(Long.toString(diffTime));\r
- dlogData.setPid(matches[1]);\r
- dlogData.setTid(matches[2]);\r
- dlogData.setLevel(matches[3]);\r
- dlogData.setTag(matches[4]);\r
- dlogData.setMessage(matches[5]);\r
- dlogList.add(dlogData);\r
- }\r
- \r
- } catch (ParseException e) {\r
- // TODO Auto-generated catch block\r
- e.printStackTrace();\r
- } \r
- }\r
- return dlogList;\r
- }\r
- \r
- public boolean isStart(){\r
- return start;\r
- }\r
- \r
-}\r
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Dongkye Lee <dongkyu6.lee@samsung.com>
+ * GwangHo Go <ggh1933.go@@samsung.com>
+ * Gihun Chang <gihun.chang@@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.
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.timeline.dlog;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+import org.tizen.dynamicanalyzer.util.Logger;
+
+public class DLogDBTable extends DBTable {
+ public static final String TABLENAME = "DLOG_DB";
+
+ public enum COLUMN {
+ TIME(0, "TIME"),
+ LEVEL(1, "LEVEL"),
+ PID(2, DBConstants.DBCOLUMN_PID),
+ TID(3, DBConstants.DBCOLUMN_TID),
+ TAG(4, "TAG"),
+ MESSAGE(5, "MESSAGE");
+
+ public final int index;
+ public final String name;
+
+ COLUMN(int index, String name) {
+ this.index = index;
+ this.name = name;
+ }
+ }
+
+ @Override
+ public String getTableName() {
+ return TABLENAME;
+ }
+
+ public DLogDBTable() {
+ addColumn(new DBColumn(COLUMN.TIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_VARCHAR, 20));
+ addColumn(new DBColumn(COLUMN.LEVEL.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_VARCHAR, 10));
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_VARCHAR, 10));
+ addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_VARCHAR, 10));
+ addColumn(new DBColumn(COLUMN.TAG.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_VARCHAR, 64));
+ addColumn(new DBColumn(COLUMN.MESSAGE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_VARCHAR, 4096));
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ int index = 1;
+ prep.setString(index++, (String) (rowData.get(COLUMN.TIME.index)));
+ prep.setString(index++, (String) (rowData.get(COLUMN.LEVEL.index)));
+ prep.setString(index++, (String) (rowData.get(COLUMN.PID.index)));
+ prep.setString(index++, (String) (rowData.get(COLUMN.TID.index)));
+ prep.setString(index++, (String) (rowData.get(COLUMN.TAG.index)));
+ prep.setString(index++, (String) (rowData.get(COLUMN.MESSAGE.index)));
+ } catch (SQLException e) {
+ Logger.exception(e);
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ int index = 1;
+ row.add(rs.getString(index++));
+ row.add(rs.getString(index++));
+ row.add(rs.getString(index++));
+ row.add(rs.getString(index++));
+ row.add(rs.getString(index++));
+ row.add(rs.getString(index++));
+ } catch (SQLException e) {
+ Logger.exception(e);
+ return null;
+ }
+
+ return row;
+ }
+
+}
--- /dev/null
+package org.tizen.dynamicanalyzer.ui.timeline.dlog;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
+import org.tizen.dynamicanalyzer.communicator.DeviceInfo;
+import org.tizen.dynamicanalyzer.database.DBInserter;
+import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
+import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager;
+import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.sdblib.receiver.MultiLineReceiver;
+import org.tizen.sdblib.util.StringUtil;
+
+public class DLogDataManager extends PageDataManager {
+
+ private static DLogDataManager instance = new DLogDataManager();
+ private Thread dlogthread = null;
+
+ private DLogDBTable dLogDBTable = null;
+ private DBInserter dLogDBInserter = null;
+
+ public DLogDataManager() {
+ dLogDBTable = new DLogDBTable();
+ dLogDBInserter = makeInserter(dLogDBTable);
+ }
+
+ public static DLogDataManager getInstance() {
+ return instance;
+ }
+
+ public DLogDBTable getDBTable() {
+ return dLogDBTable;
+ }
+
+ @Override
+ protected void makeData(LogPackage pack) {
+ }
+
+ private static final Pattern pattern = Pattern.compile("\\d{2}-\\d{2}\\s(\\d{2}:\\d{2}:\\d{2}\\.?\\d*)\\+?\\d*\\s+" // time
+ + "(\\d+)\\s+" // pid
+ + "(\\d+)\\s+" // tid
+ + "(V|D|I|W|E|F)\\s+" // level
+ + "(\\S+)\\s*\\:\\s+" // tag
+ + "(.*)"); // message
+
+ static boolean start = false;
+ private boolean dlogKill = false;
+ static String[] daStartTime = null;
+
+ public boolean getDlogKill() {
+ return dlogKill;
+ }
+
+ public void setDlogKill(boolean killed) {
+ if (dlogthread != null) {
+ dlogKill = killed;
+ }
+ }
+
+ public boolean startDlog() {
+ final DeviceInfo curDev = Global.getCurrentDeviceInfo();
+
+ dlogKill = false;
+
+ if (curDev == null) {
+ return false;
+ }
+
+ String datecommand = "date +\"%H:%M:%S.%3N\"";
+
+ CommunicatorUtils.execShellCommand(curDev.getIDevice(), datecommand, new MultiLineReceiver() {
+ @Override
+ public void processNewLines(String[] appLines) {
+ for (int i = 0; i < appLines.length; i++) {
+ daStartTime = appLines;
+ }
+ }
+ });
+
+ Global.getProject().setDAStartTime(daStartTime[0]);
+
+ CommunicatorUtils.execShellCommand(curDev.getIDevice(), "/usr/bin/dlogutil -c");
+
+ dlogthread = new Thread(new Runnable() {
+
+ @Override
+ public void run() {
+ CommunicatorUtils.execShellCommand(curDev.getIDevice(), "/usr/bin/dlogutil -v threadtime",
+ new MultiLineReceiver() {
+ @Override
+ public void processNewLines(String[] appLines) {
+ if (dlogKill) {
+ start = false;
+ try {
+ Logger.debug("Dlog receiver joined");
+ Thread.currentThread().join();
+ } catch (InterruptedException e) {
+
+ }
+ }
+
+ if (appLines != null) {
+ makeDlogData(appLines);
+ }
+ }
+ });
+ }
+ });
+
+ dlogthread.start();
+ start = true;
+
+ return true;
+ }
+
+ public void stopDlog() {
+ setDlogKill(true);
+ }
+
+ private void makeDlogData(String[] dlogs) {
+ if (dlogs.length > 0) {
+ List<List<Object>> mList = new ArrayList<List<Object>>();
+
+ for (int i = 0; i < dlogs.length; i++) {
+ String dlogstring = dlogs[i];
+
+ List<Object> dlog = splitDlog(dlogstring);
+
+ if (dlog != null) {
+ mList.add(dlog);
+ }
+ }
+ dLogDBInserter.pushData(mList);
+ }
+ }
+
+ private List<Object> splitDlog(String dlog) {
+ List<Object> splited = new ArrayList<Object>();
+
+ String[] matches = StringUtil.split(dlog, pattern);
+ if (matches == null || matches.length != 6)
+ return null;
+
+ if (matches[5].contains("swap_start")) {
+ if (Global.getProject() != null) {
+ Global.getProject().setDAStartTime(matches[0]);
+ }
+ }
+
+ for (int i = 0; i < matches.length; i++) {
+ splited.add(String.valueOf(matches[i]));
+ }
+
+ return splited;
+ }
+
+ public List<DADlogData> parserDlogs() {
+ List<DADlogData> dlogList = new ArrayList<DADlogData>();
+
+ DateFormat formatter = new SimpleDateFormat("hh:mm:ss.SSS");
+
+ List<List<Object>> Dlogs = getDlogFromDB();
+
+ String dastart = Global.getProject().getDAStartTime();
+
+ if (dastart == null || dastart.isEmpty()) {
+ dastart = (String) Dlogs.get(0).get(0);
+ }
+
+ Date DAStartTime = null;
+ try {
+ DAStartTime = formatter.parse(dastart);
+ } catch (ParseException e1) {
+ // TODO Auto-generated catch block
+ e1.printStackTrace();
+ }
+
+ for (List<Object> dlog : Dlogs) {
+ DADlogData dlogData = new DADlogData();
+ try {
+ Date date = formatter.parse((String) dlog.get(0));
+ dlogData.setSyncTime(DAStartTime);
+
+ int compare = date.compareTo(DAStartTime);
+
+ if (compare < 0) {
+ continue;
+ } else {
+ long diffTime = date.getTime() * 1000 - DAStartTime.getTime() * 1000;
+
+ // dlogData.setTime(matches[0]);
+ dlogData.setTime(Long.toString(diffTime));
+ dlogData.setPid((String) dlog.get(1));
+ dlogData.setTid((String) dlog.get(2));
+ dlogData.setLevel((String) dlog.get(3));
+ dlogData.setTag((String) dlog.get(4));
+ dlogData.setMessage((String) dlog.get(5));
+ dlogList.add(dlogData);
+ }
+
+ } catch (ParseException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+ return dlogList;
+ }
+
+ public boolean isStart() {
+ return start;
+ }
+
+ private List<List<Object>> getDlogFromDB() {
+ List<List<Object>> dlogdatas = new ArrayList<List<Object>>();
+
+ List<List<Object>> queryResult = dLogDBTable.selectAllColumnData(null);
+ if (queryResult == null) {
+ return dlogdatas;
+ }
+ dlogdatas = queryResult;
+
+ return dlogdatas;
+ }
+}
+/*\r
+ * Dynamic Analyzer\r
+ *\r
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
+ * Contact: \r
+ * GwangHo Go <ggh1933.go@@samsung.com>\r
+ * Dongkye Lee <dongkyu6.lee@samsung.com>\r
+ * Gihun Chang <gihun.chang@@samsung.com>\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ * \r
+ */\r
+\r
+\r
package org.tizen.dynamicanalyzer.ui.timeline.dlog;\r
\r
import java.util.ArrayList;\r
import org.eclipse.swt.widgets.MenuItem;\r
import org.eclipse.swt.widgets.Shell;\r
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
+import org.tizen.dynamicanalyzer.common.Global;\r
import org.tizen.dynamicanalyzer.model.TableInput;\r
import org.tizen.dynamicanalyzer.ui.common.UICommonConstants;\r
import org.tizen.dynamicanalyzer.ui.page.BaseView;\r
public class DlogTable extends DATableComposite {\r
\r
private String[] columnNames = {"Time", "Level", "Pid", "Tid", "Tag", "Message" }; //6col\r
- private int[] columnSizes = { 80, 80, 80, 80, 300, 1200};\r
+ private int[] columnSizes = { 80, 60, 70, 70, 100, 1200};\r
private int[] columnAlignment = { SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT };\r
private boolean[] columnVisibility = { true, true, true, true, true, true };\r
private int[] sortTypes = { AnalyzerConstants.SORT_TYPE_NONE, AnalyzerConstants.SORT_TYPE_NONE, AnalyzerConstants.SORT_TYPE_NONE,\r
AnalyzerConstants.SORT_TYPE_NONE,AnalyzerConstants.SORT_TYPE_NONE, AnalyzerConstants.SORT_TYPE_NONE };\r
\r
- private DADlogReceiver dlogRecv = new DADlogReceiver(); \r
private List<TableInput> tableClone = new ArrayList<TableInput>();\r
private List<TableInput> filteredDlog = new ArrayList<TableInput>();\r
private static boolean isFilter = false;\r
}\r
@Override\r
protected List<TableInput> makeTableInput() {\r
- \r
List<TableInput> output = new ArrayList<TableInput>();\r
List<DADlogData> dlogData = new ArrayList<DADlogData>();\r
\r
- if(dlogRecv.getDlogs()!=null){\r
- dlogData = dlogRecv.parserDlogs();\r
- }\r
- else {\r
- tableClone = output;\r
- return output;\r
- }\r
+ dlogData = DLogDataManager.getInstance().parserDlogs();\r
\r
int seqnum = 0;\r
\r
tableClone = output;\r
return output;\r
}\r
- /*\r
- protected void addTableData() {\r
- \r
- List<DADlogData> dlogData = dlogRecv.parserDlogs();\r
- \r
- for(DADlogData data : dlogData){\r
- GridItem item = new GridItem(table, SWT.LEFT);\r
- item.setText(data.getTime());\r
- item.setText(data.getTag());\r
- item.setText(data.getPid());\r
- item.setText(data.getMessage());\r
- }\r
- \r
- }\r
- */\r
+ \r
@Override\r
public void updateTable() {\r
- if(!DADlogReceiver.dlogKill){\r
- return;\r
- }\r
- int itemCount = 0;\r
- if(dlogRecv.isStart() == true){\r
- itemCount = dlogRecv.parserDlogs().size();\r
- }\r
- else {\r
- return;\r
- }\r
- if (itemCount <= 0) {\r
- return;\r
+ if(Global.getProject().isSaveProject() == false) {\r
+ if(!DLogDataManager.getInstance().getDlogKill()){\r
+ return;\r
+ } \r
}\r
-\r
+ \r
List<TableInput> output = null;\r
output = makeTableInput();\r
\r
if(tableClone != null){\r
for(TableInput table : tableClone){\r
if(table.getText().get(4).contains(input)){\r
- //private String time;\r
- //private String pid;\r
- //private String tid; \r
- //private String level;\r
- //private String tag;\r
- //private String message;\r
filteredDlog.add(table);\r
isFilter = true;\r
}\r
+/*\r
+ * Dynamic Analyzer\r
+ *\r
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
+ * Contact: \r
+ * GwangHo Go <ggh1933.go@@samsung.com>\r
+ * Dongkye Lee <dongkyu6.lee@samsung.com>\r
+ * Gihun Chang <gihun.chang@@samsung.com>\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ * \r
+ */\r
+\r
+\r
package org.tizen.dynamicanalyzer.ui.timeline.dlog;\r
\r
import org.eclipse.swt.layout.FillLayout;\r
\r
Composite contents = null;\r
private DATableComposite DlogTable = null;\r
- \r
+\r
public DlogView(Composite parent, int style) {\r
super(parent, style, false);\r
this.setLayout(new FillLayout());\r
- \r
+\r
setTitle(InformationViewLabels.DLOG_VIEW_TITLE);\r
contents = getContentArea();\r
contents.setBackground(ColorResources.WINDOW_BG_COLOR);\r
contents.setLayout(new FillLayout());\r
- \r
- DlogTable = new DlogTable(contents, SWT.NONE, SWT.SINGLE\r
- | SWT.BORDER | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL);\r
-
- DlogTable.setTableToolTipEnable(false); \r
- }\r
- \r
+\r
+ DlogTable = new DlogTable(contents, SWT.NONE,\r
+ SWT.SINGLE | SWT.BORDER | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL);\r
+\r
+ DlogTable.setTableToolTipEnable(false); }\r
+\r
@Override\r
public void updateView() {\r
if (!AnalyzerManager.isVisibleView(this.getID())) {\r
return;\r
}\r
+ \r
if (null == DlogTable) {\r
return;\r
}\r
- if(DADlogReceiver.dlogKill){\r
- DlogTable.updateTable();\r
- }\r
+ \r
+ DlogTable.updateTable();\r
}\r
\r
@Override\r
public void clear() {\r
DlogTable.clear();\r
- DADlogReceiver.dlogKill = false;\r
+ DLogDataManager.getInstance().setDlogKill(false);\r
}\r
\r
@Override\r
projects / sdk / tools / dynamic-analyzer.git / commitdiff