return Collections.unmodifiableList(dataList);
}
- public boolean buildFrom(List<K> keylist, List<V> valuelist) {
- if(keylist == null || valuelist == null || keylist.size() != valuelist.size()) {
+ public boolean buildFrom(List<K> keylist, List<V> valuelist, int maxindex) {
+ if (keylist == null || valuelist == null || keylist.size() != valuelist.size()
+ || maxindex < 0) {
return false;
}
-
+
clear();
-
- int size = keylist.size();
- for(int i = 0; i < size; i++) {
+
+ // retain list space
+ for (int i = 0; i < maxindex + 1; i++) {
dataList.add(null);
}
-
- for(int i = 0; i < size; i++) {
+
+ int size = keylist.size();
+ for (int i = 0; i < size; i++) {
V val = valuelist.get(i);
int index = val.getIndex();
dataMap.put(keylist.get(i), val);
dataList.set(index, val);
}
-
+
return true;
}
}
import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands;
import org.tizen.dynamicanalyzer.common.DAResult;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.protocol.ProtocolConstants;
import org.tizen.dynamicanalyzer.protocol.p30.Communicator30;
+import org.tizen.dynamicanalyzer.protocol.p40.Communicator40;
import org.tizen.dynamicanalyzer.ui.info.screenshot.EmulatorScreenshot;
import org.tizen.dynamicanalyzer.ui.info.screenshot.SocketClient;
import org.tizen.dynamicanalyzer.util.ByteUtil;
}
private String checkVersionByMessage() {
- // TODO : implement for protocol 4.0 or later
// if the target is legacy(3.0), the target send the ACK message without version string
- return null;
+ String version = null;
+
+ ProtocolSerializer ps = new ProtocolSerializer();
+ ps.setMessageID(ProtocolConstants.MSG_VERSION);
+ byte[] msg = ps.toByteArray();
+
+ AckMessage result = handleControlMessage(msg);
+ if (result != null && result.isSuccess()
+ && result.isCorrectID(ProtocolConstants.MSG_VERSION_ACK)) {
+ if (result.getPayloadLength() > INT_SIZE) {
+ // protocol 4.0 or later
+ // parse for version string
+ byte[] pbyte = result.getPayload();
+ if (pbyte != null) {
+ ProtocolParser parser = new ProtocolParser(pbyte);
+ parser.getInt(); // for return code
+
+ version = parser.getString();
+ }
+ } else {
+ // legacy(3.0), version message treated as keep alive message
+ // do nothing
+ }
+ }
+
+ return version;
}
private String checkVersionByCommand() {
DAResult result = DAResult.SUCCESS;
if (VERSION40.equals(protocolVersion)) {
- // TODO : make sub communicator for protocol 4.0
- subCommunicator = null;
+ subCommunicator = new Communicator40(this);
} else if (VERSION30.equals(protocolVersion)) {
subCommunicator = new Communicator30(this);
} else {
this.msgID = msgID;
}
+ public void putByte(byte val) {
+ byte[] buf = new byte[] { val };
+ payload.write(buf, 0, buf.length);
+ }
+
public void putShort(short val) {
byte[] buf = ByteUtil.toBytes(val);
payload.write(buf, 0, buf.length);
* send messages
*******************************************************/
- public abstract DAResult sendVersionMessage(IProgress progress) throws InterruptedException,
- ProtocolNotSupportedException;
-
public abstract DAResult sendTraceStartMessage(IProgress progress) throws InterruptedException,
ProtocolNotSupportedException;
import org.tizen.dynamicanalyzer.common.DAResult;
import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.setting.Feature;
import org.tizen.dynamicanalyzer.setting.SettingDataManager;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.ui.toolbar.Toolbar;
import org.tizen.dynamicanalyzer.widgets.timer.IAlarm;
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.swap.model;
+package org.tizen.dynamicanalyzer.model;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-
+import java.util.Map;
import org.tizen.dynamicanalyzer.collection.IndexedHashMap;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.database.DBTable;
private int cpuCount = 0;
private int deviceCount = 0;
private String devices = null;
- private List<String> apiNameList = null;
+ private Map<Integer, String> apiNameMap = null;
private IndexedHashMap<String, BinaryInfo> binaryInfos = new IndexedHashMap<String, BinaryInfo>();
public DeviceStatusInfo() {
}
// method for api names
- public List<String> getApiNameList() {
- if (apiNameList != null) {
- return Collections.unmodifiableList(apiNameList);
+ public Map<Integer, String> getApiNameMap() {
+ if (apiNameMap != null) {
+ return Collections.unmodifiableMap(apiNameMap);
} else {
return null;
}
}
- public void setApiNameList(List<String> functionList) {
- apiNameList = functionList;
+ public void setApiNameMap(Map<Integer, String> functionMap) {
+ apiNameMap = functionMap;
}
// get binary info if it exist in map
List<String> keylist = new ArrayList<String>();
List<BinaryInfo> valuelist = new ArrayList<BinaryInfo>();
+ int maxindex = -1;
int rowsize = datas.size();
for (int i = 0; i < rowsize; i++) {
List<Object> data = datas.get(i);
keylist.add(targetpath);
valuelist.add(binfo);
+
+ if (maxindex < id) {
+ maxindex = id;
+ }
}
- binaryInfos.buildFrom(keylist, valuelist);
+ binaryInfos.buildFrom(keylist, valuelist, maxindex);
}
}
import org.tizen.dynamicanalyzer.database.DBTableRegistry;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.handlers.UIAction;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.project.callstack.RuntimeCallstackManager;
import org.tizen.dynamicanalyzer.project.data.BinaryInfoDBTable;
import org.tizen.dynamicanalyzer.project.data.FunctionNameDBTable;
import org.tizen.dynamicanalyzer.project.data.MemoryMapDBTable;
import org.tizen.dynamicanalyzer.project.data.ProcessInfoDBTable;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
public void setDeviceStatusInfo(DeviceStatusInfo statusInfo) {
targetDeviceStatusInfo = statusInfo;
if (targetDeviceStatusInfo != null) {
- List<String> apiNameList = targetDeviceStatusInfo.getApiNameList();
- if (apiNameList != null) {
- synchronized (functionInfos) {
- int apisize = apiNameList.size();
- for (int i = 0; i < apisize; i++) {
- String functionName = apiNameList.get(i);
- FunctionInfo fninfo = new FunctionInfo(functionName);
- functionInfos.put(functionName, fninfo);
+ Map<Integer, String> apiNameMap = targetDeviceStatusInfo.getApiNameMap();
+ if (apiNameMap != null) {
+ List<String> keylist = new ArrayList<String>();
+ List<FunctionInfo> valuelist = new ArrayList<FunctionInfo>();
+
+ int maxindex = -1;
+ for (Map.Entry<Integer, String> entry : apiNameMap.entrySet()) {
+ int index = entry.getKey().intValue();
+ String apiName = entry.getValue();
+
+ FunctionInfo fninfo = new FunctionInfo(apiName);
+ fninfo.setID(index);
+
+ keylist.add(apiName);
+ valuelist.add(fninfo);
+
+ if (maxindex < index) {
+ maxindex = index;
}
}
+
+ synchronized (functionInfos) {
+ functionInfos.buildFrom(keylist, valuelist, maxindex);
+ }
}
}
}
List<String> namelist = new ArrayList<String>();
List<FunctionInfo> finfolist = new ArrayList<FunctionInfo>();
+ int maxindex = -1;
int size = datas.size();
for (int i = 0; i < size; i++) {
List<Object> functionInfo = datas.get(i);
namelist.add(name);
finfolist.add(finfo);
+
+ if (maxindex < id) {
+ maxindex = id;
+ }
}
- functionInfos.buildFrom(namelist, finfolist);
+ functionInfos.buildFrom(namelist, finfolist, maxindex);
}
}
// immutable constant value by protocol version
public class ProtocolConstants {
+ // to get protocol version
+ public static final int MSG_VERSION = 0x0001;
+ public static final int MSG_VERSION_ACK = 0x1001;
+
// sequence number
public static final long MAX_SEQ_NUMBER = 0xFFFFFFFFL;
public final static long FEATURE_INTERNAL_OSPUI_API = 0x1L << 31;
public final static long FEATURE_INTERNAL_NETWORK_API = 0x1L << 32;
public final static long FEATURE_INTERNAL_OPENGL_API = 0x1L << 33;
-
+
public final static long FEATURE_SYSTEM_CPU = 0x1L << 36;
public final static long FEATURE_SYSTEM_MEMORY = 0x1L << 37;
public final static long FEATURE_SYSTEM_PROCESS = 0x1L << 38;
public final static long FEATURE_SYSTEM_NETWORK = 0x1L << 42;
public final static long FEATURE_SYSTEM_DEVICE = 0x1L << 43;
public final static long FEATURE_SYSTEM_ENERGY = 0x1L << 44;
-
+
public final static long FEATURE_SYSTEM_FILE_ACTIVITY = 0x1L << 48;
+ // miscellaneous
+ public final static String MAIN_FUNCTION_SYMBOL = "main";
}
protected String executablePath = null;
protected List<ISerializable> functionInstList = null;
+ public int getApplicationType() {
+ return applicationType;
+ }
+
public void setApplicationType(int applicationType) {
this.applicationType = applicationType;
}
*
* Contact:
* Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.TreeMap;
import java.util.regex.Pattern;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.handlers.ReplayManager;
import org.tizen.dynamicanalyzer.handlers.UIAction;
import org.tizen.dynamicanalyzer.model.AddrSymbolPair;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.project.AppInfo;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
import org.tizen.dynamicanalyzer.project.DeviceStatusInfo;
import org.tizen.dynamicanalyzer.setting.SettingDataManager;
import org.tizen.dynamicanalyzer.setting.TargetData;
import org.tizen.dynamicanalyzer.swap.communicator.SwapErrorCode;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.swap.model.data.RecordEventObject;
import org.tizen.dynamicanalyzer.swap.model.data.ReplayData;
import org.tizen.dynamicanalyzer.ui.toolbar.replay.data.ReplayDataManager;
}
// get api map information
- parent.getDevice().getDeviceStatusInfo().setApiNameList(getApiList());
+ parent.getDevice().getDeviceStatusInfo().setApiNameMap(getApiMap());
// send configuration message
result = sendConfigurationMessage(null);
return DAResult.ERR_TARGET_INFO_GET_FAIL;
}
- protected List<String> getApiList() {
+ protected Map<Integer, String> getApiMap() {
DeviceInfo device = parent.getDevice();
final List<String> lines = new ArrayList<String>();
}
});
- List<String> apiMap = new ArrayList<String>();
- apiMap.add(AnalyzerConstants.UNKNOWN_API);
+ Map<Integer, String> apiMap = new TreeMap<Integer, String>();
+ apiMap.put(Integer.valueOf(0), AnalyzerConstants.UNKNOWN_API);
if (lines.size() > 0) {
if (!lines.get(0).contains(AnalyzerConstants.CMDSCRIPT_UNKNOWN)
String input = lines.get(i);
String[] splitLine = input.trim().split(CommonConstants.SPACE, 2);
if (splitLine.length > 1) {
- apiMap.add(new String(splitLine[1]));
+ int index = Integer.parseInt(splitLine[0]);
+ apiMap.put(Integer.valueOf(index), splitLine[1]);
} else {
Logger.debug("api map parsing is wrong");
}
FunctionInst30 functionInst = new FunctionInst30();
functionInst.setAddr(addrSymbol.getAddr());
- functionInst.setArgs(getFunctionArgs(addrSymbol.getSymbol()));
+ functionInst.setArgs(getFunctionArgs(symbol));
functionInstList.add(functionInst);
}
continue;
}
- DAResult result;
- String[] splitLocalBinaryPath = localBinaryPath.split(Pattern.quote(File.separator));
+ DAResult result = checkDirtyOfBinary(binInfo, localBinaryPath);
+ if (!result.isSuccess()) {
+ // popup warning dialog with result
+ UIAction.showWarning(result, 480, 153);
+ } else {
+ ret = DAResult.SUCCESS;
+ }
+ }
- // check local binary path validation
- // host has no binary file - pull binary file from target
- if (splitLocalBinaryPath.length < 3 || !(new File(localBinaryPath)).exists()) {
+ return ret;
+ }
+
+ protected DAResult checkDirtyOfBinary(BinaryInfo binInfo, String localBinaryPath) {
+ DAResult result = DAResult.SUCCESS;
+ String targetPath = binInfo.getTargetBinaryPath();
+
+ String[] splitLocalBinaryPath = localBinaryPath.split(Pattern.quote(File.separator));
+
+ // check local binary path validation
+ // host has no binary file - pull binary file from target
+ if (splitLocalBinaryPath.length < 3 || !(new File(localBinaryPath)).exists()) {
+ localBinaryPath = PathManager.DA_TEMP_FOLDER_PATH + File.separator
+ + getFileName(targetPath);
+ result = pullTheFile(targetPath, localBinaryPath);
+ if (result.isSuccess()) {
+ binInfo.setTempBinaryPath(localBinaryPath);
+ } else if (result.equals(DAResult.ERR_BY_SECURITY)) {
+ // continue : do nothing
+ }
+ } else {
+ // if local binary exist already, then check for md5sum
+ String localHashCode = null;
+ try {
+ Runtime rt = Runtime.getRuntime();
+ Process process = rt.exec(new String[] { getMd5Command(), localBinaryPath });
+ process.waitFor();
+ BufferedReader reader = new BufferedReader(new InputStreamReader(
+ process.getInputStream()));
+ BufferedReader error = new BufferedReader(new InputStreamReader(
+ process.getErrorStream()));
+ String line = reader.readLine();
+ String errorStr = error.readLine();
+ if (null == line) {
+ Logger.warning("host md5sum get failed : " + errorStr);
+ } else {
+ // md5sum.exe prepend "\" when target binary is not in
+ // current directory
+ if (CommonUtil.isWin()) {
+ line = line.replace("\\", "");
+ }
+ localHashCode = parseMd5Result(line);
+ }
+ } catch (IOException e) {
+ Logger.exception(e);
+ } catch (InterruptedException e) {
+ Logger.exception(e);
+ }
+
+ if (localHashCode == null || 0 != localHashCode.compareTo(binInfo.getMd5sumValue())) {
localBinaryPath = PathManager.DA_TEMP_FOLDER_PATH + File.separator
+ getFileName(targetPath);
result = pullTheFile(targetPath, localBinaryPath);
if (result.isSuccess()) {
binInfo.setTempBinaryPath(localBinaryPath);
} else if (result.equals(DAResult.ERR_BY_SECURITY)) {
- // popup by security reason
- UIAction.showWarning(result, 480, 153);
- continue;
+ // continue : do nothing
}
} else {
- // if local binary exist already, then check for md5sum
- String localHashCode = null;
- try {
- Runtime rt = Runtime.getRuntime();
- Process process = rt.exec(new String[] { getMd5Command(), localBinaryPath });
- process.waitFor();
- BufferedReader reader = new BufferedReader(new InputStreamReader(
- process.getInputStream()));
- BufferedReader error = new BufferedReader(new InputStreamReader(
- process.getErrorStream()));
- String line = reader.readLine();
- String errorStr = error.readLine();
- if (null == line) {
- Logger.debug("host md5sum get failed : " + errorStr);
- result = DAResult.ERR_BIN_INFO_GET_FAIL;
- } else {
- // md5sum.exe prepend "\" when target binary is not in
- // current directory
- if (CommonUtil.isWin()) {
- line = line.replace("\\", "");
- }
- localHashCode = parseMd5Result(line);
- }
- } catch (IOException e) {
- Logger.exception(e);
- result = DAResult.ERR_BIN_INFO_GET_FAIL;
- } catch (InterruptedException e) {
- Logger.exception(e);
- result = DAResult.ERR_BIN_INFO_GET_FAIL;
- }
-
- if (localHashCode == null || 0 != localHashCode.compareTo(binInfo.getMd5sumValue())) {
- localBinaryPath = PathManager.DA_TEMP_FOLDER_PATH + File.separator
- + getFileName(targetPath);
- result = pullTheFile(targetPath, localBinaryPath);
- if (result.isSuccess()) {
- binInfo.setTempBinaryPath(localBinaryPath);
- } else if (result.equals(DAResult.ERR_BY_SECURITY)) {
- // popup by security reason
- UIAction.showWarning(result, 480, 153);
- continue;
- }
- } else {
- binInfo.setTempBinaryPath(localBinaryPath);
- }
+ binInfo.setTempBinaryPath(localBinaryPath);
}
-
- // result succeed if getting for any binary info succeed
- ret = DAResult.SUCCESS;
}
- return ret;
+ // result succeed if getting for any binary info succeed
+ return result;
}
protected DAResult pullTheFile(String from, String to) {
}
@Override
- public DAResult sendVersionMessage(IProgress progress) throws ProtocolNotSupportedException {
- throw new ProtocolNotSupportedException();
- }
-
- @Override
public DAResult sendProbeMapMessage(IProgress progress) throws ProtocolNotSupportedException {
throw new ProtocolNotSupportedException();
}
/*
* Dynamic Analyzer
*
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
- * Heeyoung Hwang <heeyoung1008.hwang@samsung.com>
+ * Jaewon Lim <jaewon81.lim@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jaewon Lim <jaewon81.lim@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.protocol.p40;
+
+import org.tizen.dynamicanalyzer.communicator.ProtocolSerializer;
+import org.tizen.dynamicanalyzer.protocol.p30.ApplicationInst30;
+
+public class ApplicationInst40 extends ApplicationInst30 {
+ protected long mainAddress = 0;
+
+ public void setMainAddress(long addr) {
+ this.mainAddress = addr;
+ }
+
+ @Override
+ public void serialize(ProtocolSerializer ps) {
+ super.serialize(ps);
+
+ if (applicationType == ProtocolConstant40.APPTYPE_TIZEN) {
+ ps.putLong(mainAddress);
+ }
+ }
+}
package org.tizen.dynamicanalyzer.protocol.p40;
+import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.DAResult;
+import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.communicator.AckMessage;
import org.tizen.dynamicanalyzer.communicator.BaseCommunicator;
+import org.tizen.dynamicanalyzer.communicator.DeviceInfo;
+import org.tizen.dynamicanalyzer.communicator.ISerializable;
+import org.tizen.dynamicanalyzer.communicator.ProtocolNotSupportedException;
+import org.tizen.dynamicanalyzer.communicator.ProtocolParser;
+import org.tizen.dynamicanalyzer.communicator.ProtocolSerializer;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.control.ApplistManager;
+import org.tizen.dynamicanalyzer.control.IProgress;
+import org.tizen.dynamicanalyzer.handlers.UIAction;
+import org.tizen.dynamicanalyzer.model.AddrSymbolPair;
+import org.tizen.dynamicanalyzer.project.AppInfo;
+import org.tizen.dynamicanalyzer.project.BinaryInfo;
+import org.tizen.dynamicanalyzer.project.PackageInfo;
+import org.tizen.dynamicanalyzer.protocol.ProtocolConstants;
import org.tizen.dynamicanalyzer.protocol.p30.Communicator30;
+import org.tizen.dynamicanalyzer.protocol.p30.ProtocolFilter30;
+import org.tizen.dynamicanalyzer.setting.Feature;
+import org.tizen.dynamicanalyzer.setting.SettingDataManager;
+import org.tizen.dynamicanalyzer.setting.TargetData;
+import org.tizen.dynamicanalyzer.swap.communicator.SwapErrorCode;
+import org.tizen.dynamicanalyzer.util.Logger;
public class Communicator40 extends Communicator30 {
public Communicator40(BaseCommunicator parent) {
super(parent);
}
+
+ @Override
+ public DAResult connect() {
+ DAResult result;
+
+ int localPort = parent.getLocalPort();
+
+ result = createDataSocket(localPort);
+ if (!result.isSuccess()) {
+ Logger.warning(result.toString());
+ return DAResult.ERR_DATA_SOCKET_CREATION_FAIL;
+ }
+
+ // get target information
+ result = sendTargetInfoMessage(null);
+ if (!result.isSuccess()) {
+ Logger.warning(result.toString());
+ return result;
+ }
+
+ // get api map information
+ try {
+ result = sendProbeMapMessage(null);
+ if (!result.isSuccess()) {
+ Logger.warning(result.toString());
+ return result;
+ }
+ } catch (ProtocolNotSupportedException e) {
+ parent.getDevice().getDeviceStatusInfo().setApiNameMap(getApiMap());
+ }
+
+ // send configuration message
+ result = sendConfigurationMessage(null);
+ if (result.isSuccess()) {
+ parent.getDevice().setConfigSuccess(true);
+ } else {
+ Logger.warning(result.toString());
+ }
+
+ return result;
+ }
+
+ @Override
+ public DAResult sendConfigurationMessage(IProgress progress) {
+ // send config message
+ ProtocolSerializer ps = new ProtocolSerializer();
+ ps.setMessageID(ProtocolConstant40.MSG_CONFIG);
+
+ // set feature flag value
+ Set<Feature> selectedFeatures = SettingDataManager.INSTANCE.getSelectedFeatureSet();
+ byte[] featureFlag = ProtocolConfig40.getFeatureFlagValue(selectedFeatures);
+ ps.putByteArray(featureFlag);
+
+ // set sampling period value
+ TargetData target = SettingDataManager.INSTANCE.getConnectedTarget();
+ int systemPeriod = target.getSelectedFeatureValue(Feature.SYSTEM_SAMPLING_RATE);
+ if (systemPeriod < 0) {
+ systemPeriod = Feature.SYSTEM_SAMPLING_RATE.getData().getDefaultValue();
+ }
+ int samplingPeriod = target.getSelectedFeatureValue(Feature.FUNCTION_SAMPLING_RATE);
+ if (samplingPeriod < 0) {
+ samplingPeriod = Feature.FUNCTION_SAMPLING_RATE.getData().getDefaultValue();
+ }
+ ps.putInt(systemPeriod);
+ ps.putInt(samplingPeriod);
+
+ byte[] msg = ps.toByteArray();
+
+ AckMessage result = parent.handleControlMessage(msg);
+
+ if (result != null && result.isSuccess()
+ && result.isCorrectID(ProtocolConstant40.MSG_CONFIG_ACK)) {
+ return DAResult.SUCCESS;
+ } else {
+ return DAResult.ERR_CONFIG_FAILED;
+ }
+ }
+
+ @Override
+ public DAResult sendKeepAliveMessage(IProgress progress) {
+ ProtocolSerializer ps = new ProtocolSerializer();
+ ps.setMessageID(ProtocolConstant40.MSG_KEEP_ALIVE);
+ byte[] msg = ps.toByteArray();
+
+ AckMessage result = parent.handleControlMessage(msg);
+ if (result != null && result.isCorrectID(ProtocolConstant40.MSG_KEEP_ALIVE_ACK)
+ && result.isSuccess()) {
+ return DAResult.SUCCESS;
+ } else {
+ return DAResult.ERR_KEEP_ALIVE;
+ }
+ }
+
+ @Override
+ public DAResult sendScreenshotMessage(IProgress progress) {
+ ProtocolSerializer ps = new ProtocolSerializer();
+ ps.setMessageID(ProtocolConstant40.MSG_GET_SCREENSHOT);
+ byte[] msg = ps.toByteArray();
+
+ // wait ack in protocol 4.0
+ AckMessage result = parent.handleControlMessage(msg, 0);
+ if (result != null && result.isSuccess()
+ && result.isCorrectID(ProtocolConstant40.MSG_GET_SCREENSHOT_ACK)) {
+ return DAResult.SUCCESS;
+ } else {
+ return DAResult.ERR_MSG_SEND_FAIL;
+ }
+ }
+
+ @Override
+ public DAResult sendProbeMapMessage(IProgress progress) throws ProtocolNotSupportedException {
+ ProtocolSerializer ps = new ProtocolSerializer();
+ ps.setMessageID(ProtocolConstant40.MSG_GET_PROBEMAP);
+ byte[] msg = ps.toByteArray();
+
+ // wait ack in protocol 4.0
+ AckMessage result = parent.handleControlMessage(msg, 0);
+ if (result != null && result.isSuccess()
+ && result.isCorrectID(ProtocolConstant40.MSG_GET_PROBEMAP_ACK)) {
+ byte[] payload = result.getPayload();
+ if (payload != null) {
+ ProtocolParser parser = new ProtocolParser(payload);
+ parser.getInt(); // for return code
+
+ int countOfApi = parser.getInt();
+ if (countOfApi > 0) {
+ Map<Integer, String> apiNameMap = new TreeMap<Integer, String>();
+ apiNameMap.put(Integer.valueOf(0), AnalyzerConstants.UNKNOWN_API);
+
+ for (int i = 0; i < countOfApi; i++) {
+ int index = parser.getInt();
+ String apiName = parser.getString();
+ apiNameMap.put(Integer.valueOf(index), apiName);
+ }
+
+ parent.getDevice().getDeviceStatusInfo()
+ .setApiNameMap(Collections.unmodifiableMap(apiNameMap));
+ }
+ }
+
+ return DAResult.SUCCESS;
+ } else {
+ return DAResult.ERR_MSG_SEND_FAIL;
+ }
+ }
+
+ // return false if there is no application inst.
+ // return true, otherwise
+ @Override
+ protected boolean serializeApplicationInst(ProtocolSerializer ps) {
+ super.serializeApplicationInst(ps);
+
+ DeviceInfo dev = parent.getDevice();
+ String pkgID = Global.getCurrentApplication().getPackageId();
+ PackageInfo pkgInfo = dev.getPkgInfoByPkgID(pkgID);
+ List<AppInfo> apps = pkgInfo.getAppInfos();
+
+ List<ISerializable> appInstList = new ArrayList<ISerializable>();
+
+ if (pkgInfo.getPackageId().equals(AnalyzerConstants.RUNNING_PROCESS)) {
+ // if running process is selected for tracing
+ Map<Integer, String> selectedProcess = apps.get(0).getRunningProcesses();
+ if (selectedProcess != null && selectedProcess.size() > 0) {
+ for (Map.Entry<Integer, String> entry : selectedProcess.entrySet()) {
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
+ .getBinaryInfo(entry.getValue());
+ String temppath = binInfo.getTempBinaryPath();
+ if (temppath == null) {
+ // this means the app binary does not exist in device
+ continue;
+ }
+
+ ApplicationInst40 appInst = new ApplicationInst40();
+ appInst.setApplicationType(ProtocolConstant40.APPTYPE_PROCESS);
+ appInst.setApplicationID(entry.getKey().toString());
+ appInst.setExecutablePath(entry.getValue());
+
+ List<AddrSymbolPair> symbols = apps.get(0).getSymbols(temppath);
+ appInst.setFunctionInstList(getFunctionInstList(symbols));
+
+ appInstList.add(appInst);
+ }
+ }
+ } else if (pkgInfo.getPackageId().equals(AnalyzerConstants.WITHOUT_EXECUTABLE)) {
+ // if no executable is selected for tracing (system wide tracing)
+ ApplicationInst40 appInst = new ApplicationInst40();
+ appInst.setApplicationType(ProtocolConstant40.APPTYPE_PROCESS);
+ appInst.setApplicationID(CommonConstants.EMPTY);
+ appInst.setExecutablePath(CommonConstants.EMPTY);
+
+ appInstList.add(appInst);
+ } else { // normal application or common executable is selected
+ for (int k = 0; k < apps.size(); k++) {
+ AppInfo app = apps.get(k);
+
+ // check if application is in black list
+ if (ApplistManager.isInBlackList(app)) {
+ continue;
+ }
+
+ BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo()
+ .getBinaryInfo(app.getExecBinaryPath());
+ String temppath = binInfo.getTempBinaryPath();
+ if (temppath == null) {
+ // this means the app binary does not exist in device
+ continue;
+ }
+
+ List<AddrSymbolPair> symbols = app.getSymbols(temppath);
+ List<ISerializable> functionInstList = getFunctionInstList(symbols);
+ if (functionInstList.isEmpty()) {
+ // this means there is no function inst.
+ continue;
+ }
+
+ ApplicationInst40 appInst = new ApplicationInst40();
+
+ // TODO : make sure that first app of package is main app
+ if (k == 0) {
+ String appType = app.getInfo(AppInfo.PROPERTY.APPTYPE.index);
+ if (appType.contains(AppInfo.APPTYPE_CPP)) {
+ appInst.setApplicationType(ProtocolConstant40.APPTYPE_TIZEN);
+ appInst.setApplicationID(app.getAppID());
+ } else if (appType.contains(AppInfo.APPTYPE_WEB)) {
+ appInst.setApplicationType(ProtocolConstant40.APPTYPE_WEB);
+ appInst.setApplicationID(app.getAppID());
+ } else if (appType.contains(AppInfo.APPTYPE_CAPP)) {
+ appInst.setApplicationType(ProtocolConstant40.APPTYPE_TIZEN);
+ appInst.setApplicationID(app.getAppID());
+ } else {
+ appInst.setApplicationType(ProtocolConstant40.APPTYPE_COMMON_EXEC);
+ appInst.setApplicationID(CommonConstants.EMPTY);
+ }
+ } else {
+ appInst.setApplicationType(ProtocolConstant40.APPTYPE_PROCESS);
+ appInst.setApplicationID(CommonConstants.EMPTY);
+ }
+
+ // set application start-up information (main function address)
+ if (appInst.getApplicationType() == ProtocolConstant40.APPTYPE_TIZEN) {
+ for (AddrSymbolPair entry : symbols) {
+ if (entry.getSymbol().equals(ProtocolConstants.MAIN_FUNCTION_SYMBOL)) {
+ appInst.setMainAddress(entry.getAddr());
+ break;
+ }
+ }
+ }
+
+ appInst.setExecutablePath(app.getExecPath());
+ appInst.setFunctionInstList(functionInstList);
+
+ appInstList.add(appInst);
+ }
+ }
+
+ // put application inst. count
+ ps.putInt(appInstList.size());
+
+ // serialize application inst. by ProtocolSerializer
+ for (ISerializable appInst : appInstList) {
+ appInst.serialize(ps);
+ }
+
+ if (appInstList.size() == 0) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ @Override
+ protected List<ISerializable> getFunctionInstList(List<AddrSymbolPair> symbols) {
+ List<ISerializable> functionInstList = new ArrayList<ISerializable>();
+
+ int size = (symbols == null) ? 0 : symbols.size();
+ for (int i = 0; i < size; i++) {
+ AddrSymbolPair addrSymbol = symbols.get(i);
+ String symbol = addrSymbol.getSymbol();
+
+ if (ProtocolFilter30.isInBlacklistFunctionInst(symbol)) {
+ continue;
+ }
+
+ FunctionInst40 functionInst = new FunctionInst40();
+ functionInst.setAddr(addrSymbol.getAddr());
+ functionInst.setArgs(getFunctionArgs(symbol));
+ functionInst.setType(ProtocolConstant40.PROBE_COMMON);
+ functionInstList.add(functionInst);
+ }
+
+ return functionInstList;
+ }
+
+ @Override
+ public DAResult sendBinaryInfoMessage(IProgress progress, List<String> binPaths) {
+ ProtocolSerializer ps = new ProtocolSerializer();
+
+ // make message
+ ps.setMessageID(ProtocolConstant40.MSG_BINARY_INFO);
+
+ int binCount = binPaths.size();
+ ps.putInt(binCount);
+
+ for (int i = 0; i < binCount; i++) {
+ String targetPath = binPaths.get(i);
+ ps.putString(targetPath);
+ }
+
+ byte[] msg = ps.toByteArray();
+
+ AckMessage result = parent.handleControlMessage(msg);
+ if (result != null && result.isCorrectID(ProtocolConstant40.MSG_BINARY_INFO_ACK)) {
+ if (result.isSuccess()
+ || (result.getReturnCode() == SwapErrorCode.ERR_WRONG_MESSAGE_DATA
+ .getErrorNumber() && result.getPayloadLength() > INT_SIZE)) {
+
+ // parse binary info
+ return parseBinaryInfo(result.getPayload());
+ }
+ }
+
+ return DAResult.ERR_BIN_INFO_GET_FAIL;
+ }
+
+ protected DAResult parseBinaryInfo(byte[] payload) {
+ DAResult ret = DAResult.ERR_BIN_INFO_GET_FAIL;
+
+ ProtocolParser parser = new ProtocolParser(payload);
+ parser.getInt(); // for return code
+
+ DeviceInfo curDevice = parent.getDevice();
+
+ int count = parser.getInt();
+ for (int i = 0; i < count; i++) {
+ String targetPath = parser.getString();
+ BinaryInfo binInfo = curDevice.getDeviceStatusInfo().getBinaryInfo(targetPath);
+
+ int binaryType = parser.getInt();
+ String localBinaryPath = parser.getString().trim();
+ String md5sum = parser.getString();
+
+ binInfo.setType(binaryType);
+ binInfo.setMd5sumValue(md5sum);
+ binInfo.setTempBinaryPath(null);
+
+ if (binaryType < 0) {
+ // binary does not exist in target(-1) or is non-elf binary(-2)
+ // so do not try to download binary from target
+ continue;
+ }
+
+ DAResult result = checkDirtyOfBinary(binInfo, localBinaryPath);
+ if (!result.isSuccess()) {
+ // popup warning dialog with result
+ UIAction.showWarning(result, 480, 153);
+ } else {
+ ret = DAResult.SUCCESS;
+ }
+ }
+
+ return ret;
+ }
+
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jaewon Lim <jaewon81.lim@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.protocol.p40;
+
+import org.tizen.dynamicanalyzer.communicator.ProtocolSerializer;
+import org.tizen.dynamicanalyzer.protocol.p30.FunctionInst30;
+
+public class FunctionInst40 extends FunctionInst30 {
+ protected byte type = 0;
+
+ public void setType(byte type) {
+ this.type = type;
+ }
+
+ @Override
+ public void serialize(ProtocolSerializer ps) {
+ ps.putLong(addr);
+ ps.putByte(type);
+
+ if (type == ProtocolConstant40.PROBE_COMMON) {
+ ps.putByteArray(args);
+ } else if (type == ProtocolConstant40.PROBE_FBI) {
+ // TODO : implementation for FBI
+ } else if (type == ProtocolConstant40.PROBE_WEB) {
+ // do nothing
+ }
+ }
+}
/*
* Dynamic Analyzer
*
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
- * Heeyoung Hwang <heeyoung1008.hwang@samsung.com>
+ * Jaewon Lim <jaewon81.lim@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jaewon Lim <jaewon81.lim@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.protocol.p40;
+
+import org.tizen.dynamicanalyzer.protocol.p30.ProtocolConstant30;
+
+public class ProtocolConstant40 extends ProtocolConstant30 {
+ // changed from protocol 3.0
+ public final static int MSG_KEEP_ALIVE = 0x000F;
+
+ // added in protocol 4.0
+ public final static int MSG_VERSION = 0x0001;
+ public final static int MSG_GET_PROBEMAP = 0x000A;
+
+ // changed from protocol 3.0
+ public final static int MSG_KEEP_ALIVE_ACK = 0x100F;
+
+ // added in protocol 4.0
+ public final static int MSG_UNKNOWN_ACK = 0x1000;
+ public final static int MSG_VERSION_ACK = 0x1001;
+ public final static int MSG_GET_PROBEMAP_ACK = 0x100A;
+ public final static int MSG_GET_SCREENSHOT_ACK = 0x1010;
+
+ // function instrument type
+ public final static byte PROBE_COMMON = 0;
+ public final static byte PROBE_FBI = 1;
+ public final static byte PROBE_WEB = 3;
+}
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class ContextSwitchData extends LogData {
protected long pcAddr = 0; // protocol 3.0
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class ControlData extends ProbeCommonData {
private String parentName = null; // protocol 3.0
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class CustomData extends ProbeCommonData {
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class ErrorData extends LogData {
private String errorMessage = null; // protocol 3.0
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class FileData extends ProbeCommonData {
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class GLES20LogData extends ProbeCommonData {
protected long glCurrentContextName = 0; // protocol 3.0
package org.tizen.dynamicanalyzer.swap.model.data;
import org.tizen.dynamicanalyzer.communicator.ProtocolParser;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.protocol.DebugLog;
import org.tizen.dynamicanalyzer.protocol.Protocol;
import org.tizen.dynamicanalyzer.protocol.ProtocolConstants;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.util.ByteUtil;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class MemoryData extends ProbeCommonData {
protected long size = 0; // protocol 3.0
*/
package org.tizen.dynamicanalyzer.swap.model.data;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.protocol.DebugLog;
import org.tizen.dynamicanalyzer.protocol.ProtocolConstants;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
public class MemoryMapData extends LogData {
protected int pid = 0; // protocol 3.0
package org.tizen.dynamicanalyzer.swap.model.data;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class NetworkData extends ProbeCommonData {
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.DALimit;
import org.tizen.dynamicanalyzer.common.Global;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class ProbeCommonData extends LogData {
protected int apiID = 0; // protocol 3.0
*/
package org.tizen.dynamicanalyzer.swap.model.data;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.protocol.DebugLog;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
public class ProcessAddInfoData extends LogData {
protected int pid = 0; // protocol 3.0
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.project.LibraryObject;
import org.tizen.dynamicanalyzer.protocol.DebugLog;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
public class ProcessInfoData extends LogData {
protected int pid = 0; // protocol 3.0
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.protocol.ProtocolConstants;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.util.Logger;
public class ProfileData extends LogData {
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class RecordEventObject {
private int msgID = 0; // protocol 3.0
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class ReplayData extends LogData {
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class SceneData extends ProbeCommonData {
protected String sceneName = null; // protocol 3.0
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class ScreenShotData extends ProbeCommonData {
protected String imageFilePath = null; // protocol 3.0
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class SyncData extends ProbeCommonData {
protected long syncValue = 0; // protocol 3.0
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.util.UnsignedInt;
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class ThreadData extends ProbeCommonData {
protected long pThreadId = 0; // protocol 3.0
*/
package org.tizen.dynamicanalyzer.swap.model.data;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
public class UIEventData extends ProbeCommonData {
import org.tizen.dynamicanalyzer.database.DBConstants;
import org.tizen.dynamicanalyzer.database.DBTable;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.swap.model.data.RecordEventObject;
import org.tizen.dynamicanalyzer.swap.model.data.ReplayData;
import org.tizen.dynamicanalyzer.util.Logger;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.model.DATime;
import org.tizen.dynamicanalyzer.nl.ReplayEditLabels;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.ui.toolbar.replay.data.ReplayDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.replayEditor.RepalyEditSaveDialog;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;