[Title] take emulator snapshot using emulator ECS server
authorwoojin <woojin2.jung@samsung.com>
Wed, 11 Dec 2013 11:56:35 +0000 (20:56 +0900)
committerwoojin <woojin2.jung@samsung.com>
Wed, 11 Dec 2013 11:56:35 +0000 (20:56 +0900)
[Desc.] get snapshot via emulator ECS server when available
[Issue]

32 files changed:
org.tizen.dynamicanalyzer/.classpath
org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF
org.tizen.dynamicanalyzer/build.properties
org.tizen.dynamicanalyzer/lib/json-simple-1.1.1.jar [new file with mode: 0644]
org.tizen.dynamicanalyzer/lib/protobuf.jar [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/msg/ecs.proto [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/msg/ecs_ids.proto [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/msg/gen.sh [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/model/DeviceInfo.java
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EmulatorSnapshot.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EventMgr.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ILsn.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMessage.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMsgProc.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenMap.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenSet.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageQueue.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageSender.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgMgr.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_KeepAliveReq.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_MonitorNtf.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketClient.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketConstants.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketMessage.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketReceive.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/Ecs.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/EcsIds.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ScreenshotChart.java
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/ImageUtilSWT.java [new file with mode: 0644]
org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/JsonUtil.java [new file with mode: 0644]

index 98ee040..e954630 100644 (file)
@@ -9,5 +9,7 @@
        <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
        <classpathentry kind="src" path="src"/>
        <classpathentry kind="src" path="test/src"/>
+       <classpathentry kind="lib" path="lib/json-simple-1.1.1.jar"/>
+       <classpathentry kind="lib" path="lib/protobuf.jar"/>
        <classpathentry kind="output" path="bin"/>
 </classpath>
index 137150e..8a36043 100644 (file)
@@ -16,7 +16,9 @@ Bundle-ClassPath: .,
  lib/org.eclipse.cdt.debug.edc_2.0.0.201109151658.jar,
  lib/org.eclipse.cdt.dsf_2.2.0.201109151620.jar,
  lib/org.eclipse.nebula.widgets.grid_1.0.0.jar,
- lib/hsqldb.jar
+ lib/hsqldb.jar,
+ lib/json-simple-1.1.1.jar,
+ lib/protobuf.jar
 Export-Package: org.tizen.dynamicanalyzer.common,
  org.tizen.dynamicanalyzer.communicator,
  org.tizen.dynamicanalyzer.error,
index 72085fc..648b644 100644 (file)
@@ -6,12 +6,13 @@ bin.includes = .,\
                META-INF/,\\r
                theme/,\\r
                plugin.properties,\\r
-               lib/,\\r
                build.properties,\\r
                Link/,\\r
                .settings/,\\r
                .project,\\r
                .classpath,\\r
                lib/org.eclipse.nebula.widgets.grid_1.0.0.jar,\\r
-               lib/hsqldb.jar\r
+               lib/hsqldb.jar,\\r
+               lib/json-simple-1.1.1.jar,\\r
+               lib/protobuf.jar\r
 
diff --git a/org.tizen.dynamicanalyzer/lib/json-simple-1.1.1.jar b/org.tizen.dynamicanalyzer/lib/json-simple-1.1.1.jar
new file mode 100644 (file)
index 0000000..66347a6
Binary files /dev/null and b/org.tizen.dynamicanalyzer/lib/json-simple-1.1.1.jar differ
diff --git a/org.tizen.dynamicanalyzer/lib/protobuf.jar b/org.tizen.dynamicanalyzer/lib/protobuf.jar
new file mode 100644 (file)
index 0000000..be6164f
Binary files /dev/null and b/org.tizen.dynamicanalyzer/lib/protobuf.jar differ
diff --git a/org.tizen.dynamicanalyzer/src/msg/ecs.proto b/org.tizen.dynamicanalyzer/src/msg/ecs.proto
new file mode 100644 (file)
index 0000000..697acd9
--- /dev/null
@@ -0,0 +1,130 @@
+import "ecs_ids.proto";
+
+package ECS;
+
+option java_package = "org.tizen.dynamicanalyzer.ui.info.snapshot.ecs";
+
+// ======= Messages =======
+
+message CheckVersionReq {
+       required string version_str = 1;
+}
+
+message CheckVersionAns {
+       required int32 errcode = 1;
+       required string version_str = 2;
+}
+
+message KeepAliveReq {
+       optional string time_str = 1;
+}
+
+message KeepAliveAns {
+       optional string time_str = 1;
+}
+
+message InjectorReq {
+       required string category = 1;
+       required int32 length = 2;
+       required int32 group = 3;
+       required int32 action = 4; 
+       optional bytes data = 5;
+}
+
+message InjectorAns {
+       required int32 errcode = 1;
+       optional string errstr = 2;
+       required string category = 3;
+}
+
+message InjectorNtf {
+       required string category = 1;
+       required int32 length = 2;
+       required int32 group = 3;
+       required int32 action = 4; 
+       optional bytes data = 5;
+}
+
+message DeviceReq {
+       required string category = 1;
+       required int32 length = 2;
+       required int32 group = 3;
+       required int32 action = 4; 
+       optional bytes data = 5;
+}
+
+message DeviceAns {
+       required int32 errcode = 1;
+       optional string errstr = 2;
+       required string category = 3;
+       required int32 length = 4;
+       required int32 group = 5;
+       required int32 action = 6; 
+       optional bytes data = 7;
+}
+
+message DeviceNtf {
+       required string category = 1;
+       required int32 length = 2;
+       required int32 group = 3;
+       required int32 action = 4; 
+       optional bytes data = 5;
+}
+
+message MonitorReq {
+       required string command = 1;
+}
+
+message MonitorAns {
+       required int32 errcode = 1;
+       optional string errmsg = 2;
+       required string command = 3;
+       optional bytes data = 4;
+}
+
+message MonitorNtf {
+       required string command = 1;
+       optional bytes data = 2;
+}
+
+// ======= Extensions messages =======
+
+message NfcReq {
+       required string category = 1;
+       optional bytes data = 2;
+}
+
+message NfcNtf {
+       required string category = 1;
+       optional bytes data = 2;
+}
+
+// ======= Main master message =======
+
+message Master {
+       required Master_Type type = 1;
+
+       optional CheckVersionReq checkversion_req = 2;
+       optional CheckVersionAns checkversion_ans = 3;
+       
+       optional KeepAliveReq keepalive_req = 4;
+       optional KeepAliveAns keepalive_ans = 5;
+       
+       optional InjectorReq injector_req = 6;
+       optional InjectorAns injector_ans = 7;
+       optional InjectorNtf injector_ntf = 8;
+       
+       optional DeviceReq device_req = 9;
+       optional DeviceAns device_ans = 10;
+       optional DeviceNtf device_ntf = 11;
+
+       optional MonitorReq monitor_req = 12;
+       optional MonitorAns monitor_ans = 13;
+       optional MonitorNtf monitor_ntf = 14;
+
+       // Extensions 101 to 150;
+       optional NfcReq nfc_req = 101;
+       optional NfcNtf nfc_ntf = 102;
+}
+
+
diff --git a/org.tizen.dynamicanalyzer/src/msg/ecs_ids.proto b/org.tizen.dynamicanalyzer/src/msg/ecs_ids.proto
new file mode 100644 (file)
index 0000000..dc981fb
--- /dev/null
@@ -0,0 +1,22 @@
+package ECS;
+
+option java_package = "org.tizen.dynamicanalyzer.ui.info.snapshot.ecs";
+
+enum Master_Type {
+    CHECKVERSION_REQ = 2;
+    CHECKVERSION_ANS = 3;
+       KEEPALIVE_REQ = 4;
+       KEEPALIVE_ANS = 5;
+       INJECTOR_REQ = 6;
+       INJECTOR_ANS = 7;
+       INJECTOR_NTF = 8;
+       DEVICE_REQ = 9;
+       DEVICE_ANS = 10;
+       DEVICE_NTF = 11;
+       MONITOR_REQ = 12;
+       MONITOR_ANS = 13;
+       MONITOR_NTF = 14;
+
+       NFC_REQ = 101;
+       NFC_NTF = 102;
+}
diff --git a/org.tizen.dynamicanalyzer/src/msg/gen.sh b/org.tizen.dynamicanalyzer/src/msg/gen.sh
new file mode 100644 (file)
index 0000000..21cbf98
--- /dev/null
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+
+protoc -I=. --java_out=../ ecs.proto
index 4d14d27..94f4a9b 100644 (file)
@@ -31,6 +31,7 @@ import java.util.HashMap;
 import java.util.List;
 
 import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.CommonConstants;
 import org.tizen.dynamicanalyzer.common.HostResult;
 import org.tizen.dynamicanalyzer.communicator.BaseCommunicator;
 import org.tizen.dynamicanalyzer.communicator.Communicator22;
@@ -39,6 +40,7 @@ import org.tizen.dynamicanalyzer.project.AppInfo;
 import org.tizen.dynamicanalyzer.project.PackageInfo;
 import org.tizen.dynamicanalyzer.swap.channel.control.TargetInfo;
 import org.tizen.dynamicanalyzer.swap.communicator.Communicator30;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.EmulatorSnapshot;
 import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
 import org.tizen.sdblib.IDevice;
 
@@ -59,6 +61,8 @@ public class DeviceInfo {
        private int remotePort = -1;
        private Socket controlSock = null;
        private Socket dataSock = null;
+       
+       public EmulatorSnapshot emulatorSnapshot = null;
 
        public DeviceInfo(IDevice device) {
                this.device = device;
@@ -182,4 +186,14 @@ public class DeviceInfo {
        public PackageInfo getSelectedPackage(String pkgId) {
                return pkgInfoHash.get(pkgId);
        }
+       
+       public boolean isEmulator() {
+               if (device != null) {
+                       if (device.getSerialNumber()
+                                       .contains(CommonConstants.EMULATOR)) {
+                               return true;
+                       }
+               }
+               return false;
+       }
 }
index e9bbf50..27b5b92 100755 (executable)
@@ -76,6 +76,8 @@ import org.tizen.dynamicanalyzer.swap.model.data.LogDataUtils;
 import org.tizen.dynamicanalyzer.swap.platform.BinarySettingData;
 import org.tizen.dynamicanalyzer.swap.platform.BinarySettingManager;
 import org.tizen.dynamicanalyzer.ui.file.FileChartManager;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.SocketClient;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.EmulatorSnapshot;
 import org.tizen.dynamicanalyzer.ui.network.NetworkChartManager;
 import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
 import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;
@@ -93,6 +95,14 @@ public class Communicator30 extends BaseCommunicator {
 
        @Override
        public HostResult init(DeviceInfo devInfo) {
+               // connect ecs server
+               if(devInfo.isEmulator()) {
+                       if(!SocketClient.getInstance().connect()) {
+                               System.out.println("[warn] Connect to ecs server is failed");
+                       }
+                       devInfo.emulatorSnapshot = new EmulatorSnapshot();
+               }
+               
                // daemon start
                Process ps = CommunicatorUtils.execCommand(devInfo.getIDevice(),
                                AnalyzerShellCommands.DACOMMAND_RUN_MANAGER);
index 3da9d82..6f3c07a 100755 (executable)
@@ -44,11 +44,13 @@ import org.tizen.dynamicanalyzer.swap.model.data.ProfileData;
 import org.tizen.dynamicanalyzer.swap.model.data.ReplayData;
 import org.tizen.dynamicanalyzer.swap.model.data.ScreenShotData;
 import org.tizen.dynamicanalyzer.swap.model.data.SystemData;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.SocketClient;
 import org.tizen.dynamicanalyzer.ui.page.BaseView;
 import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
 import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
 import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
 import org.tizen.dynamicanalyzer.utils.ImageUtil;
+import org.tizen.dynamicanalyzer.utils.ImageUtilSWT;
 import org.tizen.sdblib.service.SyncResult;
 
 public class SWAPLogParser implements Runnable {
@@ -222,11 +224,27 @@ public class SWAPLogParser implements Runnable {
                                pushLog(log, logPack);
                        } else {
                                if (log instanceof ScreenShotData) {
-                                       String remoteImgPath = ((ScreenShotData) log)
-                                                       .getImageFilePath();
+                                       boolean bECS = false;
+                                       String remoteImgPath;
+                                       if(DACommunicator.isTargetEmulator() 
+                                                       && SocketClient.getInstance().isConnected()) {
+                                               DACommunicator.getSelectedDevice().emulatorSnapshot.send();
+                                               remoteImgPath = DACommunicator.getSelectedDevice()
+                                                               .emulatorSnapshot.getFilePath(); 
+                                               bECS = true;
+                                       } else {
+                                               remoteImgPath = ((ScreenShotData) log)
+                                                               .getImageFilePath();                                            
+                                       }
+
                                        int rotate = ((ScreenShotData) log).getOrientation();
                                        // TODO : fix
-                                       processImage(remoteImgPath, rotate);
+                                       if(bECS) {
+                                               processImagefromECS(remoteImgPath, rotate);
+                                       } else {
+                                               processImage(remoteImgPath, rotate);
+                                       }
+
                                        ImageInfo imgInfo = new ImageInfo();
                                        imgInfo.setSeq(Integer.toString(log.getSeq()));
                                        imgInfo.setTime(Long.toString(log.getTime()));
@@ -308,6 +326,55 @@ public class SWAPLogParser implements Runnable {
 
        }
 
+       private void processImagefromECS(final String path, final int angle) {
+               final String fileName = getImageName(path);
+
+               if (angle != 0) {
+                       System.out.println("[ image rotate : " + angle + " ]");
+               }
+
+               new Thread(null, new Runnable() {
+                       int count = 0;
+
+                       @Override
+                       public void run() {
+                               while (true && count < 5) {
+                                       File file = new File(path);
+                                       if (file.exists()) {
+                                               /* image resizing */
+                                               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);
+                                               if (angle == 90 || angle == 270) {
+                                                       ImageUtilSWT.resize(path, smallImagePath,
+                                                                       SMALL_IMG_HEIGHT, SMALL_IMG_WIDTH);
+                                               } else {
+                                                       ImageUtilSWT.resize(path, smallImagePath,
+                                                                       SMALL_IMG_WIDTH, SMALL_IMG_HEIGHT);
+                                               }
+
+                                               break;
+                                       } else {
+                                               System.out.println("Failed to get '" + path + "' file"); //$NON-NLS-1$ //$NON-NLS-2$
+                                               try {
+                                                       Thread.sleep(1000);
+                                                       count++;
+                                               } catch (InterruptedException e) {
+                                                       e.printStackTrace();
+                                               }
+                                       }
+                               }
+                       }
+               }, AnalyzerConstants.MESSAGE_INTERNAL_IMAGE_THREAD).start();
+
+       }
+       
        private String getImageName(String fullPath) {
                String name = null;
                name = fullPath
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EmulatorSnapshot.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EmulatorSnapshot.java
new file mode 100644 (file)
index 0000000..47e3ba0
--- /dev/null
@@ -0,0 +1,83 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com> 
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import java.io.File;
+
+import org.json.simple.JSONObject;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.utils.JsonUtil;
+
+public class EmulatorSnapshot implements ILsn {
+
+       private final String SNAPSHOT = "Snapshot";
+       private int filecount = 0;
+
+       public EmulatorSnapshot() {
+               EventMgr.getInstance().AddLsnSet(SNAPSHOT);
+               EventMgr.getInstance().AddLsn(SNAPSHOT, this);
+       }
+
+       @Override
+       public void OnEventProc(String eventname, JSONObject jsParam) {
+               String message = jsParam.get(SocketConstants.MESSAGE_RETURN).toString();
+               System.out.println("[info] " + message);
+       }
+
+       @Override
+       public void OnEventProcPB(String eventname,
+                       com.google.protobuf.GeneratedMessage param) {
+       }
+
+       public String getFilePath() {
+               String filepath, filename;
+               filename = "snapshot" + filecount;
+               filepath = AnalyzerManager.getProject().getSavePath()
+               + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
+               + File.separator + filename;
+               
+               return filepath;
+       }
+       
+       private String createSnapshotMsg() {
+               filecount++;
+               String msg = JsonUtil.encodeString(JsonUtil.CMD_EXECUTE,
+                               JsonUtil.CMD_SCREENDUMP, JsonUtil.CMD_ARGS,
+                               JsonUtil.encodeObject(JsonUtil.ARG_FILENAME, getFilePath()),
+                               SNAPSHOT);
+               return msg;
+       }
+
+       public void send() {
+               MessageSender.getInstance().sendMonitorReq(createSnapshotMsg());
+       }
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EventMgr.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EventMgr.java
new file mode 100644 (file)
index 0000000..fa49456
--- /dev/null
@@ -0,0 +1,104 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com> 
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import org.json.simple.JSONObject;
+
+public class EventMgr {
+
+       private ListenMap<ListenSet<ILsn>> m_lsns = new ListenMap<ListenSet<ILsn>>();
+
+       private static EventMgr _inst;
+
+       public static EventMgr getInstance() {
+               if (null == _inst) {
+                       _inst = new EventMgr();
+               }
+               return _inst;
+       }
+
+       public void AddLsnSet(String name) {
+               if (m_lsns.Find(name) != null) {
+                       return;
+               }
+               ListenSet<ILsn> lsn = new ListenSet<ILsn>();
+               m_lsns.add(name, lsn);
+       }
+
+       public void RemoveLsnSet(String name) {
+               m_lsns.remove(name);
+       }
+
+       public void AddLsn(String name, ILsn lsn) {
+               ListenSet<ILsn> set = m_lsns.Find(name);
+               if (set == null)
+                       return;
+
+               set.add(lsn);
+       }
+
+       public void RemoveLsn(String name, ILsn lsn) {
+               ListenSet<ILsn> set = m_lsns.Find(name);
+               if (set == null)
+                       return;
+
+               set.remove(lsn);
+       }
+
+       public void Invoke(String name, JSONObject param)
+       {
+               ListenSet<ILsn> set = m_lsns.Find(name);
+               if (set == null)
+                       return;
+
+               for (int i = 0; i < set.size(); i++) {
+                       ILsn lsn = (ILsn) set.get(i);
+                       if (lsn == null)
+                               continue;
+                       lsn.OnEventProc(name, param);
+               }
+       }
+       
+       
+       public void InvokePB(String name, com.google.protobuf.GeneratedMessage param)
+       {
+               ListenSet<ILsn> set = m_lsns.Find(name);
+               if (set == null)
+                       return;
+
+               for (int i = 0; i < set.size(); i++) {
+                       ILsn lsn = (ILsn) set.get(i);
+                       if (lsn == null)
+                               continue;
+                       lsn.OnEventProcPB(name, param);
+               }
+       }
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ILsn.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ILsn.java
new file mode 100644 (file)
index 0000000..3708eea
--- /dev/null
@@ -0,0 +1,39 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com> 
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import org.json.simple.JSONObject;
+
+public interface ILsn {
+
+       void OnEventProc(String eventname, JSONObject jsParam);
+       void OnEventProcPB(String eventname, com.google.protobuf.GeneratedMessage param);
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMessage.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMessage.java
new file mode 100644 (file)
index 0000000..9e0f8bf
--- /dev/null
@@ -0,0 +1,39 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import org.json.simple.JSONObject;
+
+public interface IMessage {
+
+       void receiveMessage(JSONObject obj);
+       
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMsgProc.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMsgProc.java
new file mode 100644 (file)
index 0000000..36a7131
--- /dev/null
@@ -0,0 +1,40 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master;
+
+public interface IMsgProc {
+       
+       //void Proc(JSONObject jsResult, JSONObject jsData);
+       void Proc(Master msg);
+
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenMap.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenMap.java
new file mode 100644 (file)
index 0000000..ad9f615
--- /dev/null
@@ -0,0 +1,56 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import java.util.Map;
+import java.util.HashMap;
+
+
+public class ListenMap <T> {
+       
+       private Map<String, T> listeners = new HashMap<String, T>();
+
+       public void add(String name, T lsn) 
+       {
+               listeners.put(name, lsn);
+       }
+       
+       public void remove(String name)
+       {
+               listeners.remove(name);
+       }
+       
+       public T Find(String name)
+       {
+               T t = listeners.get(name);
+               return t;
+       }
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenSet.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenSet.java
new file mode 100644 (file)
index 0000000..a81fb10
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class ListenSet <T>// implements ILsn
+{
+       private List<T> listeners = new ArrayList<T>();
+
+       public void add(T lsn) 
+       {
+               listeners.add(lsn);
+       }
+       
+       public void remove(T lsn)
+       {
+               listeners.remove(lsn);
+       }
+       
+       public int size()
+       {
+               return listeners.size();
+       }
+       
+       public T get(int index)
+       {
+               return listeners.get(index);
+       }
+       
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageQueue.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageQueue.java
new file mode 100644 (file)
index 0000000..907ac47
--- /dev/null
@@ -0,0 +1,78 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import java.util.LinkedList;
+
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master;
+
+public class MessageQueue {
+       
+       private LinkedList<Master> m_msgQueue = new LinkedList<Master>();
+       private static MessageQueue m_inst;
+       
+       public static MessageQueue getInstance() {
+               if (null == m_inst) {
+                       m_inst = new MessageQueue();
+               }
+               return m_inst;
+       }
+
+       
+       public void QueueMsg(Master msg)
+       {
+               m_msgQueue.add(msg);
+               this.notifyAll();
+       }
+       
+       public boolean isEmpty()
+       {
+               return m_msgQueue.isEmpty();
+       }
+       
+       public Master Poll()
+       {
+               return m_msgQueue.poll();
+       }
+       
+       /*
+       public void Wait()
+       {
+               try {
+                       m_msgQueue.wait();
+               } catch (InterruptedException e) {
+                       // TODO Auto-generated catch block
+                       e.printStackTrace();
+               }
+       }*/
+       
+
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageSender.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageSender.java
new file mode 100644 (file)
index 0000000..c5e2f0b
--- /dev/null
@@ -0,0 +1,99 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import java.io.IOException;
+
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type;
+
+public class MessageSender {
+
+       private static MessageSender m_inst;
+
+       public static MessageSender getInstance() {
+               if (null == m_inst) {
+                       m_inst = new MessageSender();
+               }
+               return m_inst;
+       }
+
+       private boolean sendMaster(Master master) {
+               int serialize_size = master.getSerializedSize();
+
+               try {
+                       SocketClient.getInstance().getOutputStream()
+                                       .writeInt(serialize_size);
+                       master.writeTo(SocketClient.getInstance().getOutputStream());
+                       SocketClient.getInstance().getOutputStream().flush();
+               } catch (IOException e) {
+                       System.out.println("[warn] " + e.getMessage());  
+                       return false;
+               }
+               return true;
+       }
+
+       public boolean sendMonitorReq(String data) {
+
+               Master.Builder masterBuilder = Master.newBuilder();
+
+               masterBuilder.setType(Master_Type.MONITOR_REQ);
+
+               MonitorReq.Builder monitorBuilder = MonitorReq.newBuilder();
+
+               monitorBuilder.setCommand(data);
+
+               masterBuilder.setMonitorReq(monitorBuilder);
+
+               Master master = masterBuilder.build();
+
+               return sendMaster(master);
+       }
+
+       public void sendKeepAliveAns() {
+               Master.Builder masterBuilder = Master.newBuilder();
+
+               masterBuilder.setType(Master_Type.KEEPALIVE_ANS);
+
+               KeepAliveAns.Builder kaBuilder = KeepAliveAns.newBuilder();
+
+               kaBuilder.setTimeStr("self");
+
+               masterBuilder.setKeepaliveAns(kaBuilder);
+
+               Master master = masterBuilder.build();
+
+               sendMaster(master);
+       }
+       
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgMgr.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgMgr.java
new file mode 100644 (file)
index 0000000..ca76cd1
--- /dev/null
@@ -0,0 +1,132 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.json.simple.JSONObject;
+import org.tizen.dynamicanalyzer.utils.JsonUtil;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type;
+
+public class MsgMgr {
+
+       private Map<Master_Type, IMsgProc> _msg_map = new HashMap<Master_Type, IMsgProc>();
+
+       private String contents = null;
+
+       MsgMgr() {
+               AddMsgProc(Master_Type.MONITOR_NTF, new MsgProc_MonitorNtf());
+               AddMsgProc(Master_Type.KEEPALIVE_REQ, new MsgProc_KeepAliveReq());
+       }
+
+       private static MsgMgr _inst;
+
+       public static MsgMgr getInstance() {
+               if (null == _inst) {
+                       _inst = new MsgMgr();
+               }
+               return _inst;
+       }
+
+       public void AddMsgProc(Master_Type type, IMsgProc proc) {
+               _msg_map.put(type, proc);
+       }
+
+       public IMsgProc FindMsgProc(Master_Type type) {
+               IMsgProc proc = _msg_map.get(type);
+               if (proc == null)
+                       return null;
+               return proc;
+       }
+
+       void ProcBufMsg(Master msg) {
+               Master_Type subtype = msg.getType();
+
+               IMsgProc proc = FindMsgProc(subtype);
+
+               if (proc == null) {
+                       System.out.println("[info] invalid message type - " + subtype.toString());                      
+                       return;
+               }
+
+               if (msg.getType() == Master_Type.MONITOR_NTF) {
+                       String message = msg.getMonitorNtf().getCommand();
+                       if (contents == null) {
+                               contents = new String(message);
+                       } else {
+                               contents = contents.substring(0, contents.length() - 7);
+                               contents += message;
+                       }
+
+                       if (!messageComplete(contents)) {
+                               return;
+                       } else {
+                               int lastBrace = contents.lastIndexOf("}");
+                               contents = contents.substring(0, lastBrace + 1);
+                               JSONObject obj = JsonUtil.decodeObject(contents);
+                               if (obj == null) {
+                                       return;
+                               }
+
+                               EventMgr.getInstance().Invoke(
+                                               (String) obj.get(SocketConstants.MESSAGE_TYPE), obj);
+                               contents = null;
+                       }
+               } else {
+                       proc.Proc(msg);
+               }
+
+       }
+
+       private boolean messageComplete(String msg) {
+               int braceCount = 0;
+               char value;
+
+               for (int i = 0; i < msg.length(); i++) {
+                       value = msg.charAt(i);
+                       if (value == 123) { // { (123), } (125)
+                               braceCount++;
+                       } else if (value == 125) {
+                               if (braceCount > 0) {
+                                       braceCount--;
+                               }
+                       }
+               }
+
+               if (braceCount == 0) {
+                       return true;
+               }
+
+               return false;
+       }
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_KeepAliveReq.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_KeepAliveReq.java
new file mode 100644 (file)
index 0000000..9bd0085
--- /dev/null
@@ -0,0 +1,46 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master;
+
+public class MsgProc_KeepAliveReq implements IMsgProc {
+
+       @Override
+       public void Proc(Master msg) {
+       
+               if (!msg.hasKeepaliveReq())
+                       return;
+
+               MessageSender.getInstance().sendKeepAliveAns();
+       }
+
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_MonitorNtf.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_MonitorNtf.java
new file mode 100644 (file)
index 0000000..9dd13cf
--- /dev/null
@@ -0,0 +1,52 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf;
+
+public class MsgProc_MonitorNtf implements IMsgProc {
+
+       @Override
+       public void Proc(Master msg) {
+       
+               if (!msg.hasMonitorNtf())
+                       return;
+               
+               MonitorNtf ntf = msg.getMonitorNtf();
+               
+               String cat = ntf.getCommand();
+               
+               EventMgr.getInstance().InvokePB(cat, ntf);
+               
+       }
+
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketClient.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketClient.java
new file mode 100644 (file)
index 0000000..9fcf899
--- /dev/null
@@ -0,0 +1,203 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com> 
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.Socket;
+import java.net.SocketException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+public class SocketClient {
+
+       private static SocketClient client;
+
+       private Socket socket;
+       private String ip = SocketConstants.DefaultIp;
+       private int port = SocketConstants.DefaultPort;
+
+       // private BufferedOutputStream output;
+       private DataOutputStream output;
+       private DataInputStream input;
+
+       public DataOutputStream getOutputStream() {
+               return output;
+       }
+
+       public DataInputStream getInputStream() {
+               return input;
+       }
+
+       private LinkedList<String> receiveQueue = new LinkedList<String>();
+       private List<IMessage> listeners = new ArrayList<IMessage>();
+
+       private boolean running = false;
+
+       public static SocketClient getInstance() {
+               if (null == client) {
+                       client = new SocketClient();
+               }
+               return client;
+       }
+
+       public boolean connect() {
+               return connect(port);
+       }
+
+       public boolean connect(int port) {
+
+               try {
+                       socket = new Socket(ip, port);
+                       System.out.println("[info] socket created." + "ip: " + ip + ", port: " + port);
+
+                       socket.setReuseAddress(true);
+
+                       output = new DataOutputStream(socket.getOutputStream());
+                       input = new DataInputStream(socket.getInputStream());
+
+                       running = true;
+
+                       new Thread(null, new SocketReceive(),
+                                       SocketConstants.SOCKET_RECEIVE_THREAD).start();
+
+                       new Thread(null, new SocketMessage(),
+                                       SocketConstants.SOCKET_MESSAGE_THREAD).start();
+
+               } catch (SocketException e) {
+                       System.out.println("[warn] " + e.getMessage());
+                       return false;
+               } catch (IOException e) {
+                       System.out.println("[warn] " + e.getMessage());                 
+                       return false;
+               }
+
+               return true;
+       }
+
+       public boolean tryClose(final Object... closeables) {
+               if (null == closeables) {
+                       return false;
+               }
+
+               for (Object obj : closeables) {
+                       if (null == obj) {
+                               continue;
+                       }
+                       try {
+                               if (obj instanceof Closeable) {
+                                       ((Closeable) obj).close();
+                               } else if (obj instanceof BufferedReader) {
+                                       ((BufferedReader) obj).close();
+                               } else if (obj instanceof Socket) {
+                                       ((Socket) obj).close();
+                               }
+                       } catch (final IOException e) {
+                               System.out.println("[warn] " + e.getMessage());                         
+                               return false;
+                       }
+               }
+
+               return true;
+       }
+
+       public boolean disconnect() {
+               boolean result = false;
+               running = false;
+
+               if (null != receiveQueue) {
+                       synchronized (receiveQueue) {
+                               receiveQueue.notifyAll();
+                       }
+               }
+
+               result = tryClose(socket);
+
+               return result;
+       }
+
+       public int getPort() {
+               return port;
+       }
+
+       public void setPort(int port) {
+               this.port = port;
+       }
+
+       public boolean isConnected() {
+               if (null == socket) {
+                       return false;
+               }
+               return socket.isConnected();
+       }
+
+       public Socket getSocket() {
+               return socket;
+       }
+
+       public String getIp() {
+               return ip;
+       }
+
+       public void setIp(String ip) {
+               this.ip = ip;
+       }
+
+       public InputStream getSockInputStream() throws IOException {
+               return socket.getInputStream();
+       }
+
+       public boolean isRunning() {
+               return running;
+       }
+
+       public void setRunning(boolean run) {
+               running = run;
+       }
+
+       public LinkedList<String> getReceiveQueue() {
+               return receiveQueue;
+       }
+
+       public void addListener(IMessage iMessage) {
+               listeners.add(iMessage);
+       }
+
+       public List<IMessage> getListener() {
+               return listeners;
+       }
+
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketConstants.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketConstants.java
new file mode 100644 (file)
index 0000000..bf7d194
--- /dev/null
@@ -0,0 +1,57 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+public class SocketConstants {
+       public static String DefaultIp = "localhost";
+       public static int DefaultPort = 27000;
+
+       public final static int MAX_BUFFER = 4096;
+
+       public final static int MAX_SEND_QUEUE_SIZE = 100000;
+       public final static int MAX_RECEIVE_QUEUE_SIZE = 100000;
+
+       public final static String MESSAGE_TYPE = "type";
+       public final static String MESSAGE_SELF = "self";
+       public final static String MESSAGE_DATA = "data";
+       public final static String MESSAGE_HEADER = "header";
+       public final static String MESSAGE_ACTION = "action";
+       public final static String MESSAGE_GROUP = "group";
+       public final static String MESSAGE_RETURN = "return";
+       public final static String MESSAGE_IJDATA = "ijdata";
+
+       public final static String SOCKET_RECEIVE_THREAD = "Socket Receive Thread";
+       public final static String SOCKET_MESSAGE_THREAD = "Socket Message Thread";
+
+       public static String RECEIVE_SHARPS = "##";
+       public static String RECEIVE_OPEN_BRACE = "{";
+
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketMessage.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketMessage.java
new file mode 100644 (file)
index 0000000..9cff781
--- /dev/null
@@ -0,0 +1,86 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import org.eclipse.swt.widgets.Display;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master;
+
+public class SocketMessage implements Runnable {
+
+//     private List<String> list = new ArrayList<String>();
+
+       @Override
+       public void run() {
+               SocketClient client = SocketClient.getInstance();
+               MessageQueue msgQueue = MessageQueue.getInstance();
+               
+               
+               while (true) {
+                       synchronized (msgQueue) {
+                               if (msgQueue.isEmpty()) {
+                                       try {
+                                               msgQueue.wait();
+                                       } catch (InterruptedException e) {
+                                               System.out.println("[severe] " + e.getMessage());
+                                       }
+                               }
+                               while (true) 
+                               {
+                                       Master msg = msgQueue.Poll();
+                                       if (msg != null) 
+                                       {
+                                               processMsg(msg);
+                                       }
+                                       else 
+                                       {
+                                               break;
+                                       }
+                               }
+                                                               
+                               if (!client.isRunning()) {
+                                       break;
+                               }
+                       }
+               }
+       }
+       
+       
+       private void processMsg(final Master msg) {
+               
+               Display.getDefault().asyncExec(new Runnable() {
+                       @Override
+                       public void run() {
+                               System.out.println("[info] processMsg");                                
+                               MsgMgr.getInstance().ProcBufMsg(msg);
+                       }
+               });
+       }
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketReceive.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketReceive.java
new file mode 100644 (file)
index 0000000..04f9c9a
--- /dev/null
@@ -0,0 +1,98 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.info.snapshot;
+
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.ByteBuffer;
+
+import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master;
+
+import com.google.protobuf.CodedInputStream;
+
+public class SocketReceive implements Runnable {
+       @Override
+       public void run() {
+               SocketClient client = SocketClient.getInstance();
+               System.out.println("[info] Socket Receive runs.");
+
+               DataInputStream in = client.getInputStream();
+               int size = 0;
+               try {
+                       while ((size = in.readInt()) > 0) {
+                               if (client.getSocket().isClosed() || !client.isRunning()) {
+                                       System.out.println("closed || not running.");
+                                       break;
+                               }
+
+                               read_data(size, in);
+
+                       }
+               } catch (final EOFException e) {
+                       client.disconnect();
+               } catch (IOException e) {
+                       client.disconnect();
+               }
+       }
+
+       private void read_data(int size, DataInputStream in) throws IOException {
+               CodedInputStream codedIn = null;
+               int available = in.available();
+
+               if (size <= available) { // case: protobuf message
+                       byte[] buff = new byte[size];
+                       int read = in.read(buff);
+                       if (read > size) {
+                               return;
+                       }
+                       codedIn = CodedInputStream.newInstance(buff);
+               } else { // case: string message
+                       BufferedReader reader = new BufferedReader(
+                                       new InputStreamReader(in));
+                       byte[] bSize = ByteBuffer.allocate(4).putInt(size).array();
+                       String message = new String(bSize, 0, 4) + reader.readLine();
+                       System.out.println("message len: " + message.length()
+                                       + ", message:" + message);
+                       // TODO: handle string message
+               }
+
+               if (codedIn != null) {
+                       Master msg = Master.parseFrom(codedIn);
+                       synchronized (MessageQueue.getInstance()) {
+                               MessageQueue.getInstance().QueueMsg(msg);
+                       }
+               }
+       }
+
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/Ecs.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/Ecs.java
new file mode 100644 (file)
index 0000000..77ad643
--- /dev/null
@@ -0,0 +1,13848 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ecs.proto
+
+package org.tizen.dynamicanalyzer.ui.info.snapshot.ecs;
+
+public final class Ecs {
+  private Ecs() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+  }
+  public interface CheckVersionReqOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string version_str = 1;
+    /**
+     * <code>required string version_str = 1;</code>
+     */
+    boolean hasVersionStr();
+    /**
+     * <code>required string version_str = 1;</code>
+     */
+    java.lang.String getVersionStr();
+    /**
+     * <code>required string version_str = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getVersionStrBytes();
+  }
+  /**
+   * Protobuf type {@code ECS.CheckVersionReq}
+   */
+  public static final class CheckVersionReq extends
+      com.google.protobuf.GeneratedMessage
+      implements CheckVersionReqOrBuilder {
+    // Use CheckVersionReq.newBuilder() to construct.
+    private CheckVersionReq(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private CheckVersionReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final CheckVersionReq defaultInstance;
+    public static CheckVersionReq getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public CheckVersionReq getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private CheckVersionReq(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              versionStr_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<CheckVersionReq> PARSER =
+        new com.google.protobuf.AbstractParser<CheckVersionReq>() {
+      public CheckVersionReq parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new CheckVersionReq(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<CheckVersionReq> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string version_str = 1;
+    public static final int VERSION_STR_FIELD_NUMBER = 1;
+    private java.lang.Object versionStr_;
+    /**
+     * <code>required string version_str = 1;</code>
+     */
+    public boolean hasVersionStr() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string version_str = 1;</code>
+     */
+    public java.lang.String getVersionStr() {
+      java.lang.Object ref = versionStr_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          versionStr_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string version_str = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getVersionStrBytes() {
+      java.lang.Object ref = versionStr_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        versionStr_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      versionStr_ = "";
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasVersionStr()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getVersionStrBytes());
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getVersionStrBytes());
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.CheckVersionReq}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        versionStr_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.versionStr_ = versionStr_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance()) return this;
+        if (other.hasVersionStr()) {
+          bitField0_ |= 0x00000001;
+          versionStr_ = other.versionStr_;
+          onChanged();
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasVersionStr()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string version_str = 1;
+      private java.lang.Object versionStr_ = "";
+      /**
+       * <code>required string version_str = 1;</code>
+       */
+      public boolean hasVersionStr() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string version_str = 1;</code>
+       */
+      public java.lang.String getVersionStr() {
+        java.lang.Object ref = versionStr_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          versionStr_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string version_str = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getVersionStrBytes() {
+        java.lang.Object ref = versionStr_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          versionStr_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string version_str = 1;</code>
+       */
+      public Builder setVersionStr(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        versionStr_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string version_str = 1;</code>
+       */
+      public Builder clearVersionStr() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        versionStr_ = getDefaultInstance().getVersionStr();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string version_str = 1;</code>
+       */
+      public Builder setVersionStrBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        versionStr_ = value;
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.CheckVersionReq)
+    }
+
+    static {
+      defaultInstance = new CheckVersionReq(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.CheckVersionReq)
+  }
+
+  public interface CheckVersionAnsOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required int32 errcode = 1;
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    boolean hasErrcode();
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    int getErrcode();
+
+    // required string version_str = 2;
+    /**
+     * <code>required string version_str = 2;</code>
+     */
+    boolean hasVersionStr();
+    /**
+     * <code>required string version_str = 2;</code>
+     */
+    java.lang.String getVersionStr();
+    /**
+     * <code>required string version_str = 2;</code>
+     */
+    com.google.protobuf.ByteString
+        getVersionStrBytes();
+  }
+  /**
+   * Protobuf type {@code ECS.CheckVersionAns}
+   */
+  public static final class CheckVersionAns extends
+      com.google.protobuf.GeneratedMessage
+      implements CheckVersionAnsOrBuilder {
+    // Use CheckVersionAns.newBuilder() to construct.
+    private CheckVersionAns(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private CheckVersionAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final CheckVersionAns defaultInstance;
+    public static CheckVersionAns getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public CheckVersionAns getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private CheckVersionAns(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 8: {
+              bitField0_ |= 0x00000001;
+              errcode_ = input.readInt32();
+              break;
+            }
+            case 18: {
+              bitField0_ |= 0x00000002;
+              versionStr_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<CheckVersionAns> PARSER =
+        new com.google.protobuf.AbstractParser<CheckVersionAns>() {
+      public CheckVersionAns parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new CheckVersionAns(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<CheckVersionAns> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required int32 errcode = 1;
+    public static final int ERRCODE_FIELD_NUMBER = 1;
+    private int errcode_;
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    public boolean hasErrcode() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    public int getErrcode() {
+      return errcode_;
+    }
+
+    // required string version_str = 2;
+    public static final int VERSION_STR_FIELD_NUMBER = 2;
+    private java.lang.Object versionStr_;
+    /**
+     * <code>required string version_str = 2;</code>
+     */
+    public boolean hasVersionStr() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>required string version_str = 2;</code>
+     */
+    public java.lang.String getVersionStr() {
+      java.lang.Object ref = versionStr_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          versionStr_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string version_str = 2;</code>
+     */
+    public com.google.protobuf.ByteString
+        getVersionStrBytes() {
+      java.lang.Object ref = versionStr_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        versionStr_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      errcode_ = 0;
+      versionStr_ = "";
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasErrcode()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasVersionStr()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeInt32(1, errcode_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, getVersionStrBytes());
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(1, errcode_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(2, getVersionStrBytes());
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.CheckVersionAns}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        errcode_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000001);
+        versionStr_ = "";
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.errcode_ = errcode_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.versionStr_ = versionStr_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance()) return this;
+        if (other.hasErrcode()) {
+          setErrcode(other.getErrcode());
+        }
+        if (other.hasVersionStr()) {
+          bitField0_ |= 0x00000002;
+          versionStr_ = other.versionStr_;
+          onChanged();
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasErrcode()) {
+          
+          return false;
+        }
+        if (!hasVersionStr()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required int32 errcode = 1;
+      private int errcode_ ;
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public boolean hasErrcode() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public int getErrcode() {
+        return errcode_;
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public Builder setErrcode(int value) {
+        bitField0_ |= 0x00000001;
+        errcode_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public Builder clearErrcode() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        errcode_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required string version_str = 2;
+      private java.lang.Object versionStr_ = "";
+      /**
+       * <code>required string version_str = 2;</code>
+       */
+      public boolean hasVersionStr() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>required string version_str = 2;</code>
+       */
+      public java.lang.String getVersionStr() {
+        java.lang.Object ref = versionStr_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          versionStr_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string version_str = 2;</code>
+       */
+      public com.google.protobuf.ByteString
+          getVersionStrBytes() {
+        java.lang.Object ref = versionStr_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          versionStr_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string version_str = 2;</code>
+       */
+      public Builder setVersionStr(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        versionStr_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string version_str = 2;</code>
+       */
+      public Builder clearVersionStr() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        versionStr_ = getDefaultInstance().getVersionStr();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string version_str = 2;</code>
+       */
+      public Builder setVersionStrBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        versionStr_ = value;
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.CheckVersionAns)
+    }
+
+    static {
+      defaultInstance = new CheckVersionAns(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.CheckVersionAns)
+  }
+
+  public interface KeepAliveReqOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // optional string time_str = 1;
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    boolean hasTimeStr();
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    java.lang.String getTimeStr();
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getTimeStrBytes();
+  }
+  /**
+   * Protobuf type {@code ECS.KeepAliveReq}
+   */
+  public static final class KeepAliveReq extends
+      com.google.protobuf.GeneratedMessage
+      implements KeepAliveReqOrBuilder {
+    // Use KeepAliveReq.newBuilder() to construct.
+    private KeepAliveReq(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private KeepAliveReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final KeepAliveReq defaultInstance;
+    public static KeepAliveReq getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public KeepAliveReq getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private KeepAliveReq(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              timeStr_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<KeepAliveReq> PARSER =
+        new com.google.protobuf.AbstractParser<KeepAliveReq>() {
+      public KeepAliveReq parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new KeepAliveReq(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<KeepAliveReq> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // optional string time_str = 1;
+    public static final int TIME_STR_FIELD_NUMBER = 1;
+    private java.lang.Object timeStr_;
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    public boolean hasTimeStr() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    public java.lang.String getTimeStr() {
+      java.lang.Object ref = timeStr_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          timeStr_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getTimeStrBytes() {
+      java.lang.Object ref = timeStr_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        timeStr_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      timeStr_ = "";
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getTimeStrBytes());
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getTimeStrBytes());
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.KeepAliveReq}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        timeStr_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.timeStr_ = timeStr_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance()) return this;
+        if (other.hasTimeStr()) {
+          bitField0_ |= 0x00000001;
+          timeStr_ = other.timeStr_;
+          onChanged();
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // optional string time_str = 1;
+      private java.lang.Object timeStr_ = "";
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public boolean hasTimeStr() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public java.lang.String getTimeStr() {
+        java.lang.Object ref = timeStr_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          timeStr_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getTimeStrBytes() {
+        java.lang.Object ref = timeStr_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          timeStr_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public Builder setTimeStr(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        timeStr_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public Builder clearTimeStr() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        timeStr_ = getDefaultInstance().getTimeStr();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public Builder setTimeStrBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        timeStr_ = value;
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.KeepAliveReq)
+    }
+
+    static {
+      defaultInstance = new KeepAliveReq(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.KeepAliveReq)
+  }
+
+  public interface KeepAliveAnsOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // optional string time_str = 1;
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    boolean hasTimeStr();
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    java.lang.String getTimeStr();
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getTimeStrBytes();
+  }
+  /**
+   * Protobuf type {@code ECS.KeepAliveAns}
+   */
+  public static final class KeepAliveAns extends
+      com.google.protobuf.GeneratedMessage
+      implements KeepAliveAnsOrBuilder {
+    // Use KeepAliveAns.newBuilder() to construct.
+    private KeepAliveAns(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private KeepAliveAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final KeepAliveAns defaultInstance;
+    public static KeepAliveAns getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public KeepAliveAns getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private KeepAliveAns(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              timeStr_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<KeepAliveAns> PARSER =
+        new com.google.protobuf.AbstractParser<KeepAliveAns>() {
+      public KeepAliveAns parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new KeepAliveAns(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<KeepAliveAns> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // optional string time_str = 1;
+    public static final int TIME_STR_FIELD_NUMBER = 1;
+    private java.lang.Object timeStr_;
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    public boolean hasTimeStr() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    public java.lang.String getTimeStr() {
+      java.lang.Object ref = timeStr_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          timeStr_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string time_str = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getTimeStrBytes() {
+      java.lang.Object ref = timeStr_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        timeStr_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      timeStr_ = "";
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getTimeStrBytes());
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getTimeStrBytes());
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.KeepAliveAns}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        timeStr_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.timeStr_ = timeStr_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance()) return this;
+        if (other.hasTimeStr()) {
+          bitField0_ |= 0x00000001;
+          timeStr_ = other.timeStr_;
+          onChanged();
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // optional string time_str = 1;
+      private java.lang.Object timeStr_ = "";
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public boolean hasTimeStr() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public java.lang.String getTimeStr() {
+        java.lang.Object ref = timeStr_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          timeStr_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getTimeStrBytes() {
+        java.lang.Object ref = timeStr_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          timeStr_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public Builder setTimeStr(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        timeStr_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public Builder clearTimeStr() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        timeStr_ = getDefaultInstance().getTimeStr();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string time_str = 1;</code>
+       */
+      public Builder setTimeStrBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        timeStr_ = value;
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.KeepAliveAns)
+    }
+
+    static {
+      defaultInstance = new KeepAliveAns(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.KeepAliveAns)
+  }
+
+  public interface InjectorReqOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string category = 1;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    boolean hasCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    java.lang.String getCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getCategoryBytes();
+
+    // required int32 length = 2;
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    boolean hasLength();
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    int getLength();
+
+    // required int32 group = 3;
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    boolean hasGroup();
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    int getGroup();
+
+    // required int32 action = 4;
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    boolean hasAction();
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    int getAction();
+
+    // optional bytes data = 5;
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.InjectorReq}
+   */
+  public static final class InjectorReq extends
+      com.google.protobuf.GeneratedMessage
+      implements InjectorReqOrBuilder {
+    // Use InjectorReq.newBuilder() to construct.
+    private InjectorReq(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private InjectorReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final InjectorReq defaultInstance;
+    public static InjectorReq getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public InjectorReq getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private InjectorReq(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              category_ = input.readBytes();
+              break;
+            }
+            case 16: {
+              bitField0_ |= 0x00000002;
+              length_ = input.readInt32();
+              break;
+            }
+            case 24: {
+              bitField0_ |= 0x00000004;
+              group_ = input.readInt32();
+              break;
+            }
+            case 32: {
+              bitField0_ |= 0x00000008;
+              action_ = input.readInt32();
+              break;
+            }
+            case 42: {
+              bitField0_ |= 0x00000010;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<InjectorReq> PARSER =
+        new com.google.protobuf.AbstractParser<InjectorReq>() {
+      public InjectorReq parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new InjectorReq(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<InjectorReq> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string category = 1;
+    public static final int CATEGORY_FIELD_NUMBER = 1;
+    private java.lang.Object category_;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public boolean hasCategory() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public java.lang.String getCategory() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          category_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCategoryBytes() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        category_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // required int32 length = 2;
+    public static final int LENGTH_FIELD_NUMBER = 2;
+    private int length_;
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    public boolean hasLength() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    public int getLength() {
+      return length_;
+    }
+
+    // required int32 group = 3;
+    public static final int GROUP_FIELD_NUMBER = 3;
+    private int group_;
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    public boolean hasGroup() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    public int getGroup() {
+      return group_;
+    }
+
+    // required int32 action = 4;
+    public static final int ACTION_FIELD_NUMBER = 4;
+    private int action_;
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    public boolean hasAction() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    public int getAction() {
+      return action_;
+    }
+
+    // optional bytes data = 5;
+    public static final int DATA_FIELD_NUMBER = 5;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      category_ = "";
+      length_ = 0;
+      group_ = 0;
+      action_ = 0;
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasCategory()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasLength()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasGroup()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasAction()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeInt32(2, length_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeInt32(3, group_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeInt32(4, action_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        output.writeBytes(5, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(2, length_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(3, group_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(4, action_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(5, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.InjectorReq}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        category_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        length_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        group_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000004);
+        action_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000008);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000010);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.category_ = category_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.length_ = length_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.group_ = group_;
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.action_ = action_;
+        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+          to_bitField0_ |= 0x00000010;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance()) return this;
+        if (other.hasCategory()) {
+          bitField0_ |= 0x00000001;
+          category_ = other.category_;
+          onChanged();
+        }
+        if (other.hasLength()) {
+          setLength(other.getLength());
+        }
+        if (other.hasGroup()) {
+          setGroup(other.getGroup());
+        }
+        if (other.hasAction()) {
+          setAction(other.getAction());
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasCategory()) {
+          
+          return false;
+        }
+        if (!hasLength()) {
+          
+          return false;
+        }
+        if (!hasGroup()) {
+          
+          return false;
+        }
+        if (!hasAction()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string category = 1;
+      private java.lang.Object category_ = "";
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public boolean hasCategory() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public java.lang.String getCategory() {
+        java.lang.Object ref = category_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          category_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCategoryBytes() {
+        java.lang.Object ref = category_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          category_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategory(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder clearCategory() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        category_ = getDefaultInstance().getCategory();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategoryBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+
+      // required int32 length = 2;
+      private int length_ ;
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public boolean hasLength() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public int getLength() {
+        return length_;
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public Builder setLength(int value) {
+        bitField0_ |= 0x00000002;
+        length_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public Builder clearLength() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        length_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 group = 3;
+      private int group_ ;
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public boolean hasGroup() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public int getGroup() {
+        return group_;
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public Builder setGroup(int value) {
+        bitField0_ |= 0x00000004;
+        group_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public Builder clearGroup() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        group_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 action = 4;
+      private int action_ ;
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public boolean hasAction() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public int getAction() {
+        return action_;
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public Builder setAction(int value) {
+        bitField0_ |= 0x00000008;
+        action_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public Builder clearAction() {
+        bitField0_ = (bitField0_ & ~0x00000008);
+        action_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 5;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000010) == 0x00000010);
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000010;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000010);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.InjectorReq)
+    }
+
+    static {
+      defaultInstance = new InjectorReq(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.InjectorReq)
+  }
+
+  public interface InjectorAnsOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required int32 errcode = 1;
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    boolean hasErrcode();
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    int getErrcode();
+
+    // optional string errstr = 2;
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    boolean hasErrstr();
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    java.lang.String getErrstr();
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    com.google.protobuf.ByteString
+        getErrstrBytes();
+
+    // required string category = 3;
+    /**
+     * <code>required string category = 3;</code>
+     */
+    boolean hasCategory();
+    /**
+     * <code>required string category = 3;</code>
+     */
+    java.lang.String getCategory();
+    /**
+     * <code>required string category = 3;</code>
+     */
+    com.google.protobuf.ByteString
+        getCategoryBytes();
+  }
+  /**
+   * Protobuf type {@code ECS.InjectorAns}
+   */
+  public static final class InjectorAns extends
+      com.google.protobuf.GeneratedMessage
+      implements InjectorAnsOrBuilder {
+    // Use InjectorAns.newBuilder() to construct.
+    private InjectorAns(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private InjectorAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final InjectorAns defaultInstance;
+    public static InjectorAns getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public InjectorAns getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private InjectorAns(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 8: {
+              bitField0_ |= 0x00000001;
+              errcode_ = input.readInt32();
+              break;
+            }
+            case 18: {
+              bitField0_ |= 0x00000002;
+              errstr_ = input.readBytes();
+              break;
+            }
+            case 26: {
+              bitField0_ |= 0x00000004;
+              category_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<InjectorAns> PARSER =
+        new com.google.protobuf.AbstractParser<InjectorAns>() {
+      public InjectorAns parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new InjectorAns(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<InjectorAns> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required int32 errcode = 1;
+    public static final int ERRCODE_FIELD_NUMBER = 1;
+    private int errcode_;
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    public boolean hasErrcode() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    public int getErrcode() {
+      return errcode_;
+    }
+
+    // optional string errstr = 2;
+    public static final int ERRSTR_FIELD_NUMBER = 2;
+    private java.lang.Object errstr_;
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    public boolean hasErrstr() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    public java.lang.String getErrstr() {
+      java.lang.Object ref = errstr_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          errstr_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    public com.google.protobuf.ByteString
+        getErrstrBytes() {
+      java.lang.Object ref = errstr_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        errstr_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // required string category = 3;
+    public static final int CATEGORY_FIELD_NUMBER = 3;
+    private java.lang.Object category_;
+    /**
+     * <code>required string category = 3;</code>
+     */
+    public boolean hasCategory() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>required string category = 3;</code>
+     */
+    public java.lang.String getCategory() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          category_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string category = 3;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCategoryBytes() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        category_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      errcode_ = 0;
+      errstr_ = "";
+      category_ = "";
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasErrcode()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasCategory()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeInt32(1, errcode_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, getErrstrBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeBytes(3, getCategoryBytes());
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(1, errcode_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(2, getErrstrBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(3, getCategoryBytes());
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.InjectorAns}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        errcode_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000001);
+        errstr_ = "";
+        bitField0_ = (bitField0_ & ~0x00000002);
+        category_ = "";
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.errcode_ = errcode_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.errstr_ = errstr_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.category_ = category_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance()) return this;
+        if (other.hasErrcode()) {
+          setErrcode(other.getErrcode());
+        }
+        if (other.hasErrstr()) {
+          bitField0_ |= 0x00000002;
+          errstr_ = other.errstr_;
+          onChanged();
+        }
+        if (other.hasCategory()) {
+          bitField0_ |= 0x00000004;
+          category_ = other.category_;
+          onChanged();
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasErrcode()) {
+          
+          return false;
+        }
+        if (!hasCategory()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required int32 errcode = 1;
+      private int errcode_ ;
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public boolean hasErrcode() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public int getErrcode() {
+        return errcode_;
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public Builder setErrcode(int value) {
+        bitField0_ |= 0x00000001;
+        errcode_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public Builder clearErrcode() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        errcode_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional string errstr = 2;
+      private java.lang.Object errstr_ = "";
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public boolean hasErrstr() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public java.lang.String getErrstr() {
+        java.lang.Object ref = errstr_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          errstr_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public com.google.protobuf.ByteString
+          getErrstrBytes() {
+        java.lang.Object ref = errstr_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          errstr_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public Builder setErrstr(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        errstr_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public Builder clearErrstr() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        errstr_ = getDefaultInstance().getErrstr();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public Builder setErrstrBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        errstr_ = value;
+        onChanged();
+        return this;
+      }
+
+      // required string category = 3;
+      private java.lang.Object category_ = "";
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public boolean hasCategory() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public java.lang.String getCategory() {
+        java.lang.Object ref = category_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          category_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCategoryBytes() {
+        java.lang.Object ref = category_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          category_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public Builder setCategory(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000004;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public Builder clearCategory() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        category_ = getDefaultInstance().getCategory();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public Builder setCategoryBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000004;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.InjectorAns)
+    }
+
+    static {
+      defaultInstance = new InjectorAns(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.InjectorAns)
+  }
+
+  public interface InjectorNtfOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string category = 1;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    boolean hasCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    java.lang.String getCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getCategoryBytes();
+
+    // required int32 length = 2;
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    boolean hasLength();
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    int getLength();
+
+    // required int32 group = 3;
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    boolean hasGroup();
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    int getGroup();
+
+    // required int32 action = 4;
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    boolean hasAction();
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    int getAction();
+
+    // optional bytes data = 5;
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.InjectorNtf}
+   */
+  public static final class InjectorNtf extends
+      com.google.protobuf.GeneratedMessage
+      implements InjectorNtfOrBuilder {
+    // Use InjectorNtf.newBuilder() to construct.
+    private InjectorNtf(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private InjectorNtf(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final InjectorNtf defaultInstance;
+    public static InjectorNtf getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public InjectorNtf getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private InjectorNtf(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              category_ = input.readBytes();
+              break;
+            }
+            case 16: {
+              bitField0_ |= 0x00000002;
+              length_ = input.readInt32();
+              break;
+            }
+            case 24: {
+              bitField0_ |= 0x00000004;
+              group_ = input.readInt32();
+              break;
+            }
+            case 32: {
+              bitField0_ |= 0x00000008;
+              action_ = input.readInt32();
+              break;
+            }
+            case 42: {
+              bitField0_ |= 0x00000010;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<InjectorNtf> PARSER =
+        new com.google.protobuf.AbstractParser<InjectorNtf>() {
+      public InjectorNtf parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new InjectorNtf(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<InjectorNtf> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string category = 1;
+    public static final int CATEGORY_FIELD_NUMBER = 1;
+    private java.lang.Object category_;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public boolean hasCategory() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public java.lang.String getCategory() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          category_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCategoryBytes() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        category_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // required int32 length = 2;
+    public static final int LENGTH_FIELD_NUMBER = 2;
+    private int length_;
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    public boolean hasLength() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    public int getLength() {
+      return length_;
+    }
+
+    // required int32 group = 3;
+    public static final int GROUP_FIELD_NUMBER = 3;
+    private int group_;
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    public boolean hasGroup() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    public int getGroup() {
+      return group_;
+    }
+
+    // required int32 action = 4;
+    public static final int ACTION_FIELD_NUMBER = 4;
+    private int action_;
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    public boolean hasAction() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    public int getAction() {
+      return action_;
+    }
+
+    // optional bytes data = 5;
+    public static final int DATA_FIELD_NUMBER = 5;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      category_ = "";
+      length_ = 0;
+      group_ = 0;
+      action_ = 0;
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasCategory()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasLength()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasGroup()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasAction()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeInt32(2, length_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeInt32(3, group_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeInt32(4, action_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        output.writeBytes(5, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(2, length_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(3, group_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(4, action_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(5, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.InjectorNtf}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        category_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        length_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        group_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000004);
+        action_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000008);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000010);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.category_ = category_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.length_ = length_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.group_ = group_;
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.action_ = action_;
+        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+          to_bitField0_ |= 0x00000010;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance()) return this;
+        if (other.hasCategory()) {
+          bitField0_ |= 0x00000001;
+          category_ = other.category_;
+          onChanged();
+        }
+        if (other.hasLength()) {
+          setLength(other.getLength());
+        }
+        if (other.hasGroup()) {
+          setGroup(other.getGroup());
+        }
+        if (other.hasAction()) {
+          setAction(other.getAction());
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasCategory()) {
+          
+          return false;
+        }
+        if (!hasLength()) {
+          
+          return false;
+        }
+        if (!hasGroup()) {
+          
+          return false;
+        }
+        if (!hasAction()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string category = 1;
+      private java.lang.Object category_ = "";
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public boolean hasCategory() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public java.lang.String getCategory() {
+        java.lang.Object ref = category_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          category_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCategoryBytes() {
+        java.lang.Object ref = category_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          category_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategory(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder clearCategory() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        category_ = getDefaultInstance().getCategory();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategoryBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+
+      // required int32 length = 2;
+      private int length_ ;
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public boolean hasLength() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public int getLength() {
+        return length_;
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public Builder setLength(int value) {
+        bitField0_ |= 0x00000002;
+        length_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public Builder clearLength() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        length_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 group = 3;
+      private int group_ ;
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public boolean hasGroup() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public int getGroup() {
+        return group_;
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public Builder setGroup(int value) {
+        bitField0_ |= 0x00000004;
+        group_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public Builder clearGroup() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        group_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 action = 4;
+      private int action_ ;
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public boolean hasAction() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public int getAction() {
+        return action_;
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public Builder setAction(int value) {
+        bitField0_ |= 0x00000008;
+        action_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public Builder clearAction() {
+        bitField0_ = (bitField0_ & ~0x00000008);
+        action_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 5;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000010) == 0x00000010);
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000010;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000010);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.InjectorNtf)
+    }
+
+    static {
+      defaultInstance = new InjectorNtf(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.InjectorNtf)
+  }
+
+  public interface DeviceReqOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string category = 1;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    boolean hasCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    java.lang.String getCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getCategoryBytes();
+
+    // required int32 length = 2;
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    boolean hasLength();
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    int getLength();
+
+    // required int32 group = 3;
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    boolean hasGroup();
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    int getGroup();
+
+    // required int32 action = 4;
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    boolean hasAction();
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    int getAction();
+
+    // optional bytes data = 5;
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.DeviceReq}
+   */
+  public static final class DeviceReq extends
+      com.google.protobuf.GeneratedMessage
+      implements DeviceReqOrBuilder {
+    // Use DeviceReq.newBuilder() to construct.
+    private DeviceReq(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private DeviceReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final DeviceReq defaultInstance;
+    public static DeviceReq getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public DeviceReq getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private DeviceReq(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              category_ = input.readBytes();
+              break;
+            }
+            case 16: {
+              bitField0_ |= 0x00000002;
+              length_ = input.readInt32();
+              break;
+            }
+            case 24: {
+              bitField0_ |= 0x00000004;
+              group_ = input.readInt32();
+              break;
+            }
+            case 32: {
+              bitField0_ |= 0x00000008;
+              action_ = input.readInt32();
+              break;
+            }
+            case 42: {
+              bitField0_ |= 0x00000010;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<DeviceReq> PARSER =
+        new com.google.protobuf.AbstractParser<DeviceReq>() {
+      public DeviceReq parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new DeviceReq(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<DeviceReq> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string category = 1;
+    public static final int CATEGORY_FIELD_NUMBER = 1;
+    private java.lang.Object category_;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public boolean hasCategory() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public java.lang.String getCategory() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          category_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCategoryBytes() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        category_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // required int32 length = 2;
+    public static final int LENGTH_FIELD_NUMBER = 2;
+    private int length_;
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    public boolean hasLength() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    public int getLength() {
+      return length_;
+    }
+
+    // required int32 group = 3;
+    public static final int GROUP_FIELD_NUMBER = 3;
+    private int group_;
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    public boolean hasGroup() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    public int getGroup() {
+      return group_;
+    }
+
+    // required int32 action = 4;
+    public static final int ACTION_FIELD_NUMBER = 4;
+    private int action_;
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    public boolean hasAction() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    public int getAction() {
+      return action_;
+    }
+
+    // optional bytes data = 5;
+    public static final int DATA_FIELD_NUMBER = 5;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      category_ = "";
+      length_ = 0;
+      group_ = 0;
+      action_ = 0;
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasCategory()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasLength()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasGroup()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasAction()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeInt32(2, length_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeInt32(3, group_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeInt32(4, action_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        output.writeBytes(5, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(2, length_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(3, group_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(4, action_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(5, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.DeviceReq}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        category_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        length_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        group_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000004);
+        action_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000008);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000010);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.category_ = category_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.length_ = length_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.group_ = group_;
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.action_ = action_;
+        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+          to_bitField0_ |= 0x00000010;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance()) return this;
+        if (other.hasCategory()) {
+          bitField0_ |= 0x00000001;
+          category_ = other.category_;
+          onChanged();
+        }
+        if (other.hasLength()) {
+          setLength(other.getLength());
+        }
+        if (other.hasGroup()) {
+          setGroup(other.getGroup());
+        }
+        if (other.hasAction()) {
+          setAction(other.getAction());
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasCategory()) {
+          
+          return false;
+        }
+        if (!hasLength()) {
+          
+          return false;
+        }
+        if (!hasGroup()) {
+          
+          return false;
+        }
+        if (!hasAction()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string category = 1;
+      private java.lang.Object category_ = "";
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public boolean hasCategory() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public java.lang.String getCategory() {
+        java.lang.Object ref = category_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          category_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCategoryBytes() {
+        java.lang.Object ref = category_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          category_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategory(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder clearCategory() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        category_ = getDefaultInstance().getCategory();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategoryBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+
+      // required int32 length = 2;
+      private int length_ ;
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public boolean hasLength() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public int getLength() {
+        return length_;
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public Builder setLength(int value) {
+        bitField0_ |= 0x00000002;
+        length_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public Builder clearLength() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        length_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 group = 3;
+      private int group_ ;
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public boolean hasGroup() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public int getGroup() {
+        return group_;
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public Builder setGroup(int value) {
+        bitField0_ |= 0x00000004;
+        group_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public Builder clearGroup() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        group_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 action = 4;
+      private int action_ ;
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public boolean hasAction() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public int getAction() {
+        return action_;
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public Builder setAction(int value) {
+        bitField0_ |= 0x00000008;
+        action_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public Builder clearAction() {
+        bitField0_ = (bitField0_ & ~0x00000008);
+        action_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 5;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000010) == 0x00000010);
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000010;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000010);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.DeviceReq)
+    }
+
+    static {
+      defaultInstance = new DeviceReq(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.DeviceReq)
+  }
+
+  public interface DeviceAnsOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required int32 errcode = 1;
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    boolean hasErrcode();
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    int getErrcode();
+
+    // optional string errstr = 2;
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    boolean hasErrstr();
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    java.lang.String getErrstr();
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    com.google.protobuf.ByteString
+        getErrstrBytes();
+
+    // required string category = 3;
+    /**
+     * <code>required string category = 3;</code>
+     */
+    boolean hasCategory();
+    /**
+     * <code>required string category = 3;</code>
+     */
+    java.lang.String getCategory();
+    /**
+     * <code>required string category = 3;</code>
+     */
+    com.google.protobuf.ByteString
+        getCategoryBytes();
+
+    // required int32 length = 4;
+    /**
+     * <code>required int32 length = 4;</code>
+     */
+    boolean hasLength();
+    /**
+     * <code>required int32 length = 4;</code>
+     */
+    int getLength();
+
+    // required int32 group = 5;
+    /**
+     * <code>required int32 group = 5;</code>
+     */
+    boolean hasGroup();
+    /**
+     * <code>required int32 group = 5;</code>
+     */
+    int getGroup();
+
+    // required int32 action = 6;
+    /**
+     * <code>required int32 action = 6;</code>
+     */
+    boolean hasAction();
+    /**
+     * <code>required int32 action = 6;</code>
+     */
+    int getAction();
+
+    // optional bytes data = 7;
+    /**
+     * <code>optional bytes data = 7;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 7;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.DeviceAns}
+   */
+  public static final class DeviceAns extends
+      com.google.protobuf.GeneratedMessage
+      implements DeviceAnsOrBuilder {
+    // Use DeviceAns.newBuilder() to construct.
+    private DeviceAns(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private DeviceAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final DeviceAns defaultInstance;
+    public static DeviceAns getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public DeviceAns getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private DeviceAns(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 8: {
+              bitField0_ |= 0x00000001;
+              errcode_ = input.readInt32();
+              break;
+            }
+            case 18: {
+              bitField0_ |= 0x00000002;
+              errstr_ = input.readBytes();
+              break;
+            }
+            case 26: {
+              bitField0_ |= 0x00000004;
+              category_ = input.readBytes();
+              break;
+            }
+            case 32: {
+              bitField0_ |= 0x00000008;
+              length_ = input.readInt32();
+              break;
+            }
+            case 40: {
+              bitField0_ |= 0x00000010;
+              group_ = input.readInt32();
+              break;
+            }
+            case 48: {
+              bitField0_ |= 0x00000020;
+              action_ = input.readInt32();
+              break;
+            }
+            case 58: {
+              bitField0_ |= 0x00000040;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<DeviceAns> PARSER =
+        new com.google.protobuf.AbstractParser<DeviceAns>() {
+      public DeviceAns parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new DeviceAns(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<DeviceAns> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required int32 errcode = 1;
+    public static final int ERRCODE_FIELD_NUMBER = 1;
+    private int errcode_;
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    public boolean hasErrcode() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    public int getErrcode() {
+      return errcode_;
+    }
+
+    // optional string errstr = 2;
+    public static final int ERRSTR_FIELD_NUMBER = 2;
+    private java.lang.Object errstr_;
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    public boolean hasErrstr() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    public java.lang.String getErrstr() {
+      java.lang.Object ref = errstr_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          errstr_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string errstr = 2;</code>
+     */
+    public com.google.protobuf.ByteString
+        getErrstrBytes() {
+      java.lang.Object ref = errstr_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        errstr_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // required string category = 3;
+    public static final int CATEGORY_FIELD_NUMBER = 3;
+    private java.lang.Object category_;
+    /**
+     * <code>required string category = 3;</code>
+     */
+    public boolean hasCategory() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>required string category = 3;</code>
+     */
+    public java.lang.String getCategory() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          category_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string category = 3;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCategoryBytes() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        category_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // required int32 length = 4;
+    public static final int LENGTH_FIELD_NUMBER = 4;
+    private int length_;
+    /**
+     * <code>required int32 length = 4;</code>
+     */
+    public boolean hasLength() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>required int32 length = 4;</code>
+     */
+    public int getLength() {
+      return length_;
+    }
+
+    // required int32 group = 5;
+    public static final int GROUP_FIELD_NUMBER = 5;
+    private int group_;
+    /**
+     * <code>required int32 group = 5;</code>
+     */
+    public boolean hasGroup() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>required int32 group = 5;</code>
+     */
+    public int getGroup() {
+      return group_;
+    }
+
+    // required int32 action = 6;
+    public static final int ACTION_FIELD_NUMBER = 6;
+    private int action_;
+    /**
+     * <code>required int32 action = 6;</code>
+     */
+    public boolean hasAction() {
+      return ((bitField0_ & 0x00000020) == 0x00000020);
+    }
+    /**
+     * <code>required int32 action = 6;</code>
+     */
+    public int getAction() {
+      return action_;
+    }
+
+    // optional bytes data = 7;
+    public static final int DATA_FIELD_NUMBER = 7;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 7;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000040) == 0x00000040);
+    }
+    /**
+     * <code>optional bytes data = 7;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      errcode_ = 0;
+      errstr_ = "";
+      category_ = "";
+      length_ = 0;
+      group_ = 0;
+      action_ = 0;
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasErrcode()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasCategory()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasLength()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasGroup()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasAction()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeInt32(1, errcode_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, getErrstrBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeBytes(3, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeInt32(4, length_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        output.writeInt32(5, group_);
+      }
+      if (((bitField0_ & 0x00000020) == 0x00000020)) {
+        output.writeInt32(6, action_);
+      }
+      if (((bitField0_ & 0x00000040) == 0x00000040)) {
+        output.writeBytes(7, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(1, errcode_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(2, getErrstrBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(3, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(4, length_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(5, group_);
+      }
+      if (((bitField0_ & 0x00000020) == 0x00000020)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(6, action_);
+      }
+      if (((bitField0_ & 0x00000040) == 0x00000040)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(7, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.DeviceAns}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        errcode_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000001);
+        errstr_ = "";
+        bitField0_ = (bitField0_ & ~0x00000002);
+        category_ = "";
+        bitField0_ = (bitField0_ & ~0x00000004);
+        length_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000008);
+        group_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000010);
+        action_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000020);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000040);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.errcode_ = errcode_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.errstr_ = errstr_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.category_ = category_;
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.length_ = length_;
+        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+          to_bitField0_ |= 0x00000010;
+        }
+        result.group_ = group_;
+        if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+          to_bitField0_ |= 0x00000020;
+        }
+        result.action_ = action_;
+        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
+          to_bitField0_ |= 0x00000040;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance()) return this;
+        if (other.hasErrcode()) {
+          setErrcode(other.getErrcode());
+        }
+        if (other.hasErrstr()) {
+          bitField0_ |= 0x00000002;
+          errstr_ = other.errstr_;
+          onChanged();
+        }
+        if (other.hasCategory()) {
+          bitField0_ |= 0x00000004;
+          category_ = other.category_;
+          onChanged();
+        }
+        if (other.hasLength()) {
+          setLength(other.getLength());
+        }
+        if (other.hasGroup()) {
+          setGroup(other.getGroup());
+        }
+        if (other.hasAction()) {
+          setAction(other.getAction());
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasErrcode()) {
+          
+          return false;
+        }
+        if (!hasCategory()) {
+          
+          return false;
+        }
+        if (!hasLength()) {
+          
+          return false;
+        }
+        if (!hasGroup()) {
+          
+          return false;
+        }
+        if (!hasAction()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required int32 errcode = 1;
+      private int errcode_ ;
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public boolean hasErrcode() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public int getErrcode() {
+        return errcode_;
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public Builder setErrcode(int value) {
+        bitField0_ |= 0x00000001;
+        errcode_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public Builder clearErrcode() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        errcode_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional string errstr = 2;
+      private java.lang.Object errstr_ = "";
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public boolean hasErrstr() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public java.lang.String getErrstr() {
+        java.lang.Object ref = errstr_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          errstr_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public com.google.protobuf.ByteString
+          getErrstrBytes() {
+        java.lang.Object ref = errstr_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          errstr_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public Builder setErrstr(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        errstr_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public Builder clearErrstr() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        errstr_ = getDefaultInstance().getErrstr();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string errstr = 2;</code>
+       */
+      public Builder setErrstrBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        errstr_ = value;
+        onChanged();
+        return this;
+      }
+
+      // required string category = 3;
+      private java.lang.Object category_ = "";
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public boolean hasCategory() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public java.lang.String getCategory() {
+        java.lang.Object ref = category_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          category_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCategoryBytes() {
+        java.lang.Object ref = category_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          category_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public Builder setCategory(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000004;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public Builder clearCategory() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        category_ = getDefaultInstance().getCategory();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 3;</code>
+       */
+      public Builder setCategoryBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000004;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+
+      // required int32 length = 4;
+      private int length_ ;
+      /**
+       * <code>required int32 length = 4;</code>
+       */
+      public boolean hasLength() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>required int32 length = 4;</code>
+       */
+      public int getLength() {
+        return length_;
+      }
+      /**
+       * <code>required int32 length = 4;</code>
+       */
+      public Builder setLength(int value) {
+        bitField0_ |= 0x00000008;
+        length_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 length = 4;</code>
+       */
+      public Builder clearLength() {
+        bitField0_ = (bitField0_ & ~0x00000008);
+        length_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 group = 5;
+      private int group_ ;
+      /**
+       * <code>required int32 group = 5;</code>
+       */
+      public boolean hasGroup() {
+        return ((bitField0_ & 0x00000010) == 0x00000010);
+      }
+      /**
+       * <code>required int32 group = 5;</code>
+       */
+      public int getGroup() {
+        return group_;
+      }
+      /**
+       * <code>required int32 group = 5;</code>
+       */
+      public Builder setGroup(int value) {
+        bitField0_ |= 0x00000010;
+        group_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 group = 5;</code>
+       */
+      public Builder clearGroup() {
+        bitField0_ = (bitField0_ & ~0x00000010);
+        group_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 action = 6;
+      private int action_ ;
+      /**
+       * <code>required int32 action = 6;</code>
+       */
+      public boolean hasAction() {
+        return ((bitField0_ & 0x00000020) == 0x00000020);
+      }
+      /**
+       * <code>required int32 action = 6;</code>
+       */
+      public int getAction() {
+        return action_;
+      }
+      /**
+       * <code>required int32 action = 6;</code>
+       */
+      public Builder setAction(int value) {
+        bitField0_ |= 0x00000020;
+        action_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 action = 6;</code>
+       */
+      public Builder clearAction() {
+        bitField0_ = (bitField0_ & ~0x00000020);
+        action_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 7;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 7;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000040) == 0x00000040);
+      }
+      /**
+       * <code>optional bytes data = 7;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 7;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000040;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 7;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000040);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.DeviceAns)
+    }
+
+    static {
+      defaultInstance = new DeviceAns(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.DeviceAns)
+  }
+
+  public interface DeviceNtfOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string category = 1;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    boolean hasCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    java.lang.String getCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getCategoryBytes();
+
+    // required int32 length = 2;
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    boolean hasLength();
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    int getLength();
+
+    // required int32 group = 3;
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    boolean hasGroup();
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    int getGroup();
+
+    // required int32 action = 4;
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    boolean hasAction();
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    int getAction();
+
+    // optional bytes data = 5;
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.DeviceNtf}
+   */
+  public static final class DeviceNtf extends
+      com.google.protobuf.GeneratedMessage
+      implements DeviceNtfOrBuilder {
+    // Use DeviceNtf.newBuilder() to construct.
+    private DeviceNtf(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private DeviceNtf(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final DeviceNtf defaultInstance;
+    public static DeviceNtf getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public DeviceNtf getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private DeviceNtf(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              category_ = input.readBytes();
+              break;
+            }
+            case 16: {
+              bitField0_ |= 0x00000002;
+              length_ = input.readInt32();
+              break;
+            }
+            case 24: {
+              bitField0_ |= 0x00000004;
+              group_ = input.readInt32();
+              break;
+            }
+            case 32: {
+              bitField0_ |= 0x00000008;
+              action_ = input.readInt32();
+              break;
+            }
+            case 42: {
+              bitField0_ |= 0x00000010;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<DeviceNtf> PARSER =
+        new com.google.protobuf.AbstractParser<DeviceNtf>() {
+      public DeviceNtf parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new DeviceNtf(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<DeviceNtf> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string category = 1;
+    public static final int CATEGORY_FIELD_NUMBER = 1;
+    private java.lang.Object category_;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public boolean hasCategory() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public java.lang.String getCategory() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          category_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCategoryBytes() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        category_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // required int32 length = 2;
+    public static final int LENGTH_FIELD_NUMBER = 2;
+    private int length_;
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    public boolean hasLength() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>required int32 length = 2;</code>
+     */
+    public int getLength() {
+      return length_;
+    }
+
+    // required int32 group = 3;
+    public static final int GROUP_FIELD_NUMBER = 3;
+    private int group_;
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    public boolean hasGroup() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>required int32 group = 3;</code>
+     */
+    public int getGroup() {
+      return group_;
+    }
+
+    // required int32 action = 4;
+    public static final int ACTION_FIELD_NUMBER = 4;
+    private int action_;
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    public boolean hasAction() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>required int32 action = 4;</code>
+     */
+    public int getAction() {
+      return action_;
+    }
+
+    // optional bytes data = 5;
+    public static final int DATA_FIELD_NUMBER = 5;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>optional bytes data = 5;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      category_ = "";
+      length_ = 0;
+      group_ = 0;
+      action_ = 0;
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasCategory()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasLength()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasGroup()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasAction()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeInt32(2, length_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeInt32(3, group_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeInt32(4, action_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        output.writeBytes(5, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(2, length_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(3, group_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(4, action_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(5, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.DeviceNtf}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        category_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        length_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        group_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000004);
+        action_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000008);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000010);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.category_ = category_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.length_ = length_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.group_ = group_;
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.action_ = action_;
+        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+          to_bitField0_ |= 0x00000010;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance()) return this;
+        if (other.hasCategory()) {
+          bitField0_ |= 0x00000001;
+          category_ = other.category_;
+          onChanged();
+        }
+        if (other.hasLength()) {
+          setLength(other.getLength());
+        }
+        if (other.hasGroup()) {
+          setGroup(other.getGroup());
+        }
+        if (other.hasAction()) {
+          setAction(other.getAction());
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasCategory()) {
+          
+          return false;
+        }
+        if (!hasLength()) {
+          
+          return false;
+        }
+        if (!hasGroup()) {
+          
+          return false;
+        }
+        if (!hasAction()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string category = 1;
+      private java.lang.Object category_ = "";
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public boolean hasCategory() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public java.lang.String getCategory() {
+        java.lang.Object ref = category_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          category_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCategoryBytes() {
+        java.lang.Object ref = category_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          category_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategory(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder clearCategory() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        category_ = getDefaultInstance().getCategory();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategoryBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+
+      // required int32 length = 2;
+      private int length_ ;
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public boolean hasLength() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public int getLength() {
+        return length_;
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public Builder setLength(int value) {
+        bitField0_ |= 0x00000002;
+        length_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 length = 2;</code>
+       */
+      public Builder clearLength() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        length_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 group = 3;
+      private int group_ ;
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public boolean hasGroup() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public int getGroup() {
+        return group_;
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public Builder setGroup(int value) {
+        bitField0_ |= 0x00000004;
+        group_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 group = 3;</code>
+       */
+      public Builder clearGroup() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        group_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // required int32 action = 4;
+      private int action_ ;
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public boolean hasAction() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public int getAction() {
+        return action_;
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public Builder setAction(int value) {
+        bitField0_ |= 0x00000008;
+        action_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 action = 4;</code>
+       */
+      public Builder clearAction() {
+        bitField0_ = (bitField0_ & ~0x00000008);
+        action_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 5;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000010) == 0x00000010);
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000010;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 5;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000010);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.DeviceNtf)
+    }
+
+    static {
+      defaultInstance = new DeviceNtf(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.DeviceNtf)
+  }
+
+  public interface MonitorReqOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string command = 1;
+    /**
+     * <code>required string command = 1;</code>
+     */
+    boolean hasCommand();
+    /**
+     * <code>required string command = 1;</code>
+     */
+    java.lang.String getCommand();
+    /**
+     * <code>required string command = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getCommandBytes();
+  }
+  /**
+   * Protobuf type {@code ECS.MonitorReq}
+   */
+  public static final class MonitorReq extends
+      com.google.protobuf.GeneratedMessage
+      implements MonitorReqOrBuilder {
+    // Use MonitorReq.newBuilder() to construct.
+    private MonitorReq(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private MonitorReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final MonitorReq defaultInstance;
+    public static MonitorReq getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public MonitorReq getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private MonitorReq(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              command_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<MonitorReq> PARSER =
+        new com.google.protobuf.AbstractParser<MonitorReq>() {
+      public MonitorReq parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new MonitorReq(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<MonitorReq> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string command = 1;
+    public static final int COMMAND_FIELD_NUMBER = 1;
+    private java.lang.Object command_;
+    /**
+     * <code>required string command = 1;</code>
+     */
+    public boolean hasCommand() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string command = 1;</code>
+     */
+    public java.lang.String getCommand() {
+      java.lang.Object ref = command_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          command_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string command = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCommandBytes() {
+      java.lang.Object ref = command_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        command_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      command_ = "";
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasCommand()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getCommandBytes());
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getCommandBytes());
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.MonitorReq}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        command_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.command_ = command_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance()) return this;
+        if (other.hasCommand()) {
+          bitField0_ |= 0x00000001;
+          command_ = other.command_;
+          onChanged();
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasCommand()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string command = 1;
+      private java.lang.Object command_ = "";
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public boolean hasCommand() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public java.lang.String getCommand() {
+        java.lang.Object ref = command_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          command_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCommandBytes() {
+        java.lang.Object ref = command_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          command_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public Builder setCommand(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        command_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public Builder clearCommand() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        command_ = getDefaultInstance().getCommand();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public Builder setCommandBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        command_ = value;
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.MonitorReq)
+    }
+
+    static {
+      defaultInstance = new MonitorReq(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.MonitorReq)
+  }
+
+  public interface MonitorAnsOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required int32 errcode = 1;
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    boolean hasErrcode();
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    int getErrcode();
+
+    // optional string errmsg = 2;
+    /**
+     * <code>optional string errmsg = 2;</code>
+     */
+    boolean hasErrmsg();
+    /**
+     * <code>optional string errmsg = 2;</code>
+     */
+    java.lang.String getErrmsg();
+    /**
+     * <code>optional string errmsg = 2;</code>
+     */
+    com.google.protobuf.ByteString
+        getErrmsgBytes();
+
+    // required string command = 3;
+    /**
+     * <code>required string command = 3;</code>
+     */
+    boolean hasCommand();
+    /**
+     * <code>required string command = 3;</code>
+     */
+    java.lang.String getCommand();
+    /**
+     * <code>required string command = 3;</code>
+     */
+    com.google.protobuf.ByteString
+        getCommandBytes();
+
+    // optional bytes data = 4;
+    /**
+     * <code>optional bytes data = 4;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 4;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.MonitorAns}
+   */
+  public static final class MonitorAns extends
+      com.google.protobuf.GeneratedMessage
+      implements MonitorAnsOrBuilder {
+    // Use MonitorAns.newBuilder() to construct.
+    private MonitorAns(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private MonitorAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final MonitorAns defaultInstance;
+    public static MonitorAns getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public MonitorAns getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private MonitorAns(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 8: {
+              bitField0_ |= 0x00000001;
+              errcode_ = input.readInt32();
+              break;
+            }
+            case 18: {
+              bitField0_ |= 0x00000002;
+              errmsg_ = input.readBytes();
+              break;
+            }
+            case 26: {
+              bitField0_ |= 0x00000004;
+              command_ = input.readBytes();
+              break;
+            }
+            case 34: {
+              bitField0_ |= 0x00000008;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<MonitorAns> PARSER =
+        new com.google.protobuf.AbstractParser<MonitorAns>() {
+      public MonitorAns parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new MonitorAns(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<MonitorAns> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required int32 errcode = 1;
+    public static final int ERRCODE_FIELD_NUMBER = 1;
+    private int errcode_;
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    public boolean hasErrcode() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required int32 errcode = 1;</code>
+     */
+    public int getErrcode() {
+      return errcode_;
+    }
+
+    // optional string errmsg = 2;
+    public static final int ERRMSG_FIELD_NUMBER = 2;
+    private java.lang.Object errmsg_;
+    /**
+     * <code>optional string errmsg = 2;</code>
+     */
+    public boolean hasErrmsg() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional string errmsg = 2;</code>
+     */
+    public java.lang.String getErrmsg() {
+      java.lang.Object ref = errmsg_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          errmsg_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string errmsg = 2;</code>
+     */
+    public com.google.protobuf.ByteString
+        getErrmsgBytes() {
+      java.lang.Object ref = errmsg_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        errmsg_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // required string command = 3;
+    public static final int COMMAND_FIELD_NUMBER = 3;
+    private java.lang.Object command_;
+    /**
+     * <code>required string command = 3;</code>
+     */
+    public boolean hasCommand() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>required string command = 3;</code>
+     */
+    public java.lang.String getCommand() {
+      java.lang.Object ref = command_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          command_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string command = 3;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCommandBytes() {
+      java.lang.Object ref = command_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        command_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // optional bytes data = 4;
+    public static final int DATA_FIELD_NUMBER = 4;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 4;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>optional bytes data = 4;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      errcode_ = 0;
+      errmsg_ = "";
+      command_ = "";
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasErrcode()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasCommand()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeInt32(1, errcode_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, getErrmsgBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeBytes(3, getCommandBytes());
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeBytes(4, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(1, errcode_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(2, getErrmsgBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(3, getCommandBytes());
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(4, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.MonitorAns}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        errcode_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000001);
+        errmsg_ = "";
+        bitField0_ = (bitField0_ & ~0x00000002);
+        command_ = "";
+        bitField0_ = (bitField0_ & ~0x00000004);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000008);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.errcode_ = errcode_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.errmsg_ = errmsg_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.command_ = command_;
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance()) return this;
+        if (other.hasErrcode()) {
+          setErrcode(other.getErrcode());
+        }
+        if (other.hasErrmsg()) {
+          bitField0_ |= 0x00000002;
+          errmsg_ = other.errmsg_;
+          onChanged();
+        }
+        if (other.hasCommand()) {
+          bitField0_ |= 0x00000004;
+          command_ = other.command_;
+          onChanged();
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasErrcode()) {
+          
+          return false;
+        }
+        if (!hasCommand()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required int32 errcode = 1;
+      private int errcode_ ;
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public boolean hasErrcode() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public int getErrcode() {
+        return errcode_;
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public Builder setErrcode(int value) {
+        bitField0_ |= 0x00000001;
+        errcode_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int32 errcode = 1;</code>
+       */
+      public Builder clearErrcode() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        errcode_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional string errmsg = 2;
+      private java.lang.Object errmsg_ = "";
+      /**
+       * <code>optional string errmsg = 2;</code>
+       */
+      public boolean hasErrmsg() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional string errmsg = 2;</code>
+       */
+      public java.lang.String getErrmsg() {
+        java.lang.Object ref = errmsg_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          errmsg_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string errmsg = 2;</code>
+       */
+      public com.google.protobuf.ByteString
+          getErrmsgBytes() {
+        java.lang.Object ref = errmsg_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          errmsg_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string errmsg = 2;</code>
+       */
+      public Builder setErrmsg(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        errmsg_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string errmsg = 2;</code>
+       */
+      public Builder clearErrmsg() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        errmsg_ = getDefaultInstance().getErrmsg();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string errmsg = 2;</code>
+       */
+      public Builder setErrmsgBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        errmsg_ = value;
+        onChanged();
+        return this;
+      }
+
+      // required string command = 3;
+      private java.lang.Object command_ = "";
+      /**
+       * <code>required string command = 3;</code>
+       */
+      public boolean hasCommand() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>required string command = 3;</code>
+       */
+      public java.lang.String getCommand() {
+        java.lang.Object ref = command_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          command_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string command = 3;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCommandBytes() {
+        java.lang.Object ref = command_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          command_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string command = 3;</code>
+       */
+      public Builder setCommand(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000004;
+        command_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string command = 3;</code>
+       */
+      public Builder clearCommand() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        command_ = getDefaultInstance().getCommand();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string command = 3;</code>
+       */
+      public Builder setCommandBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000004;
+        command_ = value;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 4;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 4;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>optional bytes data = 4;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 4;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000008;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 4;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000008);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.MonitorAns)
+    }
+
+    static {
+      defaultInstance = new MonitorAns(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.MonitorAns)
+  }
+
+  public interface MonitorNtfOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string command = 1;
+    /**
+     * <code>required string command = 1;</code>
+     */
+    boolean hasCommand();
+    /**
+     * <code>required string command = 1;</code>
+     */
+    java.lang.String getCommand();
+    /**
+     * <code>required string command = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getCommandBytes();
+
+    // optional bytes data = 2;
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.MonitorNtf}
+   */
+  public static final class MonitorNtf extends
+      com.google.protobuf.GeneratedMessage
+      implements MonitorNtfOrBuilder {
+    // Use MonitorNtf.newBuilder() to construct.
+    private MonitorNtf(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private MonitorNtf(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final MonitorNtf defaultInstance;
+    public static MonitorNtf getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public MonitorNtf getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private MonitorNtf(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              command_ = input.readBytes();
+              break;
+            }
+            case 18: {
+              bitField0_ |= 0x00000002;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<MonitorNtf> PARSER =
+        new com.google.protobuf.AbstractParser<MonitorNtf>() {
+      public MonitorNtf parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new MonitorNtf(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<MonitorNtf> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string command = 1;
+    public static final int COMMAND_FIELD_NUMBER = 1;
+    private java.lang.Object command_;
+    /**
+     * <code>required string command = 1;</code>
+     */
+    public boolean hasCommand() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string command = 1;</code>
+     */
+    public java.lang.String getCommand() {
+      java.lang.Object ref = command_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          command_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string command = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCommandBytes() {
+      java.lang.Object ref = command_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        command_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // optional bytes data = 2;
+    public static final int DATA_FIELD_NUMBER = 2;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      command_ = "";
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasCommand()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getCommandBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getCommandBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(2, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.MonitorNtf}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        command_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.command_ = command_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance()) return this;
+        if (other.hasCommand()) {
+          bitField0_ |= 0x00000001;
+          command_ = other.command_;
+          onChanged();
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasCommand()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string command = 1;
+      private java.lang.Object command_ = "";
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public boolean hasCommand() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public java.lang.String getCommand() {
+        java.lang.Object ref = command_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          command_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCommandBytes() {
+        java.lang.Object ref = command_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          command_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public Builder setCommand(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        command_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public Builder clearCommand() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        command_ = getDefaultInstance().getCommand();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string command = 1;</code>
+       */
+      public Builder setCommandBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        command_ = value;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 2;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.MonitorNtf)
+    }
+
+    static {
+      defaultInstance = new MonitorNtf(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.MonitorNtf)
+  }
+
+  public interface NfcReqOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string category = 1;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    boolean hasCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    java.lang.String getCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getCategoryBytes();
+
+    // optional bytes data = 2;
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.NfcReq}
+   */
+  public static final class NfcReq extends
+      com.google.protobuf.GeneratedMessage
+      implements NfcReqOrBuilder {
+    // Use NfcReq.newBuilder() to construct.
+    private NfcReq(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private NfcReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final NfcReq defaultInstance;
+    public static NfcReq getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public NfcReq getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private NfcReq(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              category_ = input.readBytes();
+              break;
+            }
+            case 18: {
+              bitField0_ |= 0x00000002;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<NfcReq> PARSER =
+        new com.google.protobuf.AbstractParser<NfcReq>() {
+      public NfcReq parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new NfcReq(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<NfcReq> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string category = 1;
+    public static final int CATEGORY_FIELD_NUMBER = 1;
+    private java.lang.Object category_;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public boolean hasCategory() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public java.lang.String getCategory() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          category_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCategoryBytes() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        category_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // optional bytes data = 2;
+    public static final int DATA_FIELD_NUMBER = 2;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      category_ = "";
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasCategory()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(2, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.NfcReq}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        category_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.category_ = category_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance()) return this;
+        if (other.hasCategory()) {
+          bitField0_ |= 0x00000001;
+          category_ = other.category_;
+          onChanged();
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasCategory()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string category = 1;
+      private java.lang.Object category_ = "";
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public boolean hasCategory() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public java.lang.String getCategory() {
+        java.lang.Object ref = category_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          category_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCategoryBytes() {
+        java.lang.Object ref = category_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          category_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategory(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder clearCategory() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        category_ = getDefaultInstance().getCategory();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategoryBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 2;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.NfcReq)
+    }
+
+    static {
+      defaultInstance = new NfcReq(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.NfcReq)
+  }
+
+  public interface NfcNtfOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required string category = 1;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    boolean hasCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    java.lang.String getCategory();
+    /**
+     * <code>required string category = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getCategoryBytes();
+
+    // optional bytes data = 2;
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    boolean hasData();
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    com.google.protobuf.ByteString getData();
+  }
+  /**
+   * Protobuf type {@code ECS.NfcNtf}
+   */
+  public static final class NfcNtf extends
+      com.google.protobuf.GeneratedMessage
+      implements NfcNtfOrBuilder {
+    // Use NfcNtf.newBuilder() to construct.
+    private NfcNtf(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private NfcNtf(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final NfcNtf defaultInstance;
+    public static NfcNtf getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public NfcNtf getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private NfcNtf(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              category_ = input.readBytes();
+              break;
+            }
+            case 18: {
+              bitField0_ |= 0x00000002;
+              data_ = input.readBytes();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<NfcNtf> PARSER =
+        new com.google.protobuf.AbstractParser<NfcNtf>() {
+      public NfcNtf parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new NfcNtf(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<NfcNtf> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required string category = 1;
+    public static final int CATEGORY_FIELD_NUMBER = 1;
+    private java.lang.Object category_;
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public boolean hasCategory() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public java.lang.String getCategory() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          category_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>required string category = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getCategoryBytes() {
+      java.lang.Object ref = category_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        category_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // optional bytes data = 2;
+    public static final int DATA_FIELD_NUMBER = 2;
+    private com.google.protobuf.ByteString data_;
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    public boolean hasData() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional bytes data = 2;</code>
+     */
+    public com.google.protobuf.ByteString getData() {
+      return data_;
+    }
+
+    private void initFields() {
+      category_ = "";
+      data_ = com.google.protobuf.ByteString.EMPTY;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasCategory()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, data_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, getCategoryBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(2, data_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.NfcNtf}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        category_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        data_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.category_ = category_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.data_ = data_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance()) return this;
+        if (other.hasCategory()) {
+          bitField0_ |= 0x00000001;
+          category_ = other.category_;
+          onChanged();
+        }
+        if (other.hasData()) {
+          setData(other.getData());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasCategory()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required string category = 1;
+      private java.lang.Object category_ = "";
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public boolean hasCategory() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public java.lang.String getCategory() {
+        java.lang.Object ref = category_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          category_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getCategoryBytes() {
+        java.lang.Object ref = category_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          category_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategory(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder clearCategory() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        category_ = getDefaultInstance().getCategory();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required string category = 1;</code>
+       */
+      public Builder setCategoryBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        category_ = value;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes data = 2;
+      private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public boolean hasData() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public com.google.protobuf.ByteString getData() {
+        return data_;
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public Builder setData(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        data_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional bytes data = 2;</code>
+       */
+      public Builder clearData() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        data_ = getDefaultInstance().getData();
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.NfcNtf)
+    }
+
+    static {
+      defaultInstance = new NfcNtf(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.NfcNtf)
+  }
+
+  public interface MasterOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required .ECS.Master_Type type = 1;
+    /**
+     * <code>required .ECS.Master_Type type = 1;</code>
+     */
+    boolean hasType();
+    /**
+     * <code>required .ECS.Master_Type type = 1;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type getType();
+
+    // optional .ECS.CheckVersionReq checkversion_req = 2;
+    /**
+     * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+     */
+    boolean hasCheckversionReq();
+    /**
+     * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq getCheckversionReq();
+    /**
+     * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder getCheckversionReqOrBuilder();
+
+    // optional .ECS.CheckVersionAns checkversion_ans = 3;
+    /**
+     * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+     */
+    boolean hasCheckversionAns();
+    /**
+     * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns getCheckversionAns();
+    /**
+     * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder getCheckversionAnsOrBuilder();
+
+    // optional .ECS.KeepAliveReq keepalive_req = 4;
+    /**
+     * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+     */
+    boolean hasKeepaliveReq();
+    /**
+     * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq getKeepaliveReq();
+    /**
+     * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder getKeepaliveReqOrBuilder();
+
+    // optional .ECS.KeepAliveAns keepalive_ans = 5;
+    /**
+     * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+     */
+    boolean hasKeepaliveAns();
+    /**
+     * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns getKeepaliveAns();
+    /**
+     * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder getKeepaliveAnsOrBuilder();
+
+    // optional .ECS.InjectorReq injector_req = 6;
+    /**
+     * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+     */
+    boolean hasInjectorReq();
+    /**
+     * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq getInjectorReq();
+    /**
+     * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder getInjectorReqOrBuilder();
+
+    // optional .ECS.InjectorAns injector_ans = 7;
+    /**
+     * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+     */
+    boolean hasInjectorAns();
+    /**
+     * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns getInjectorAns();
+    /**
+     * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder getInjectorAnsOrBuilder();
+
+    // optional .ECS.InjectorNtf injector_ntf = 8;
+    /**
+     * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+     */
+    boolean hasInjectorNtf();
+    /**
+     * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf getInjectorNtf();
+    /**
+     * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder getInjectorNtfOrBuilder();
+
+    // optional .ECS.DeviceReq device_req = 9;
+    /**
+     * <code>optional .ECS.DeviceReq device_req = 9;</code>
+     */
+    boolean hasDeviceReq();
+    /**
+     * <code>optional .ECS.DeviceReq device_req = 9;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq getDeviceReq();
+    /**
+     * <code>optional .ECS.DeviceReq device_req = 9;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder getDeviceReqOrBuilder();
+
+    // optional .ECS.DeviceAns device_ans = 10;
+    /**
+     * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+     */
+    boolean hasDeviceAns();
+    /**
+     * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns getDeviceAns();
+    /**
+     * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder getDeviceAnsOrBuilder();
+
+    // optional .ECS.DeviceNtf device_ntf = 11;
+    /**
+     * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+     */
+    boolean hasDeviceNtf();
+    /**
+     * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf getDeviceNtf();
+    /**
+     * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder getDeviceNtfOrBuilder();
+
+    // optional .ECS.MonitorReq monitor_req = 12;
+    /**
+     * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+     */
+    boolean hasMonitorReq();
+    /**
+     * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq getMonitorReq();
+    /**
+     * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder getMonitorReqOrBuilder();
+
+    // optional .ECS.MonitorAns monitor_ans = 13;
+    /**
+     * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+     */
+    boolean hasMonitorAns();
+    /**
+     * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns getMonitorAns();
+    /**
+     * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder getMonitorAnsOrBuilder();
+
+    // optional .ECS.MonitorNtf monitor_ntf = 14;
+    /**
+     * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+     */
+    boolean hasMonitorNtf();
+    /**
+     * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf getMonitorNtf();
+    /**
+     * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder getMonitorNtfOrBuilder();
+
+    // optional .ECS.NfcReq nfc_req = 101;
+    /**
+     * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+     *
+     * <pre>
+     * Extensions 101 to 150;
+     * </pre>
+     */
+    boolean hasNfcReq();
+    /**
+     * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+     *
+     * <pre>
+     * Extensions 101 to 150;
+     * </pre>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq getNfcReq();
+    /**
+     * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+     *
+     * <pre>
+     * Extensions 101 to 150;
+     * </pre>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder getNfcReqOrBuilder();
+
+    // optional .ECS.NfcNtf nfc_ntf = 102;
+    /**
+     * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+     */
+    boolean hasNfcNtf();
+    /**
+     * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf getNfcNtf();
+    /**
+     * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+     */
+    org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder getNfcNtfOrBuilder();
+  }
+  /**
+   * Protobuf type {@code ECS.Master}
+   */
+  public static final class Master extends
+      com.google.protobuf.GeneratedMessage
+      implements MasterOrBuilder {
+    // Use Master.newBuilder() to construct.
+    private Master(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Master(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final Master defaultInstance;
+    public static Master getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Master getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private Master(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 8: {
+              int rawValue = input.readEnum();
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type value = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.valueOf(rawValue);
+              if (value == null) {
+                unknownFields.mergeVarintField(1, rawValue);
+              } else {
+                bitField0_ |= 0x00000001;
+                type_ = value;
+              }
+              break;
+            }
+            case 18: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000002) == 0x00000002)) {
+                subBuilder = checkversionReq_.toBuilder();
+              }
+              checkversionReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(checkversionReq_);
+                checkversionReq_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000002;
+              break;
+            }
+            case 26: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000004) == 0x00000004)) {
+                subBuilder = checkversionAns_.toBuilder();
+              }
+              checkversionAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(checkversionAns_);
+                checkversionAns_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000004;
+              break;
+            }
+            case 34: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000008) == 0x00000008)) {
+                subBuilder = keepaliveReq_.toBuilder();
+              }
+              keepaliveReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(keepaliveReq_);
+                keepaliveReq_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000008;
+              break;
+            }
+            case 42: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000010) == 0x00000010)) {
+                subBuilder = keepaliveAns_.toBuilder();
+              }
+              keepaliveAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(keepaliveAns_);
+                keepaliveAns_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000010;
+              break;
+            }
+            case 50: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000020) == 0x00000020)) {
+                subBuilder = injectorReq_.toBuilder();
+              }
+              injectorReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(injectorReq_);
+                injectorReq_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000020;
+              break;
+            }
+            case 58: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000040) == 0x00000040)) {
+                subBuilder = injectorAns_.toBuilder();
+              }
+              injectorAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(injectorAns_);
+                injectorAns_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000040;
+              break;
+            }
+            case 66: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000080) == 0x00000080)) {
+                subBuilder = injectorNtf_.toBuilder();
+              }
+              injectorNtf_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(injectorNtf_);
+                injectorNtf_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000080;
+              break;
+            }
+            case 74: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000100) == 0x00000100)) {
+                subBuilder = deviceReq_.toBuilder();
+              }
+              deviceReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(deviceReq_);
+                deviceReq_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000100;
+              break;
+            }
+            case 82: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000200) == 0x00000200)) {
+                subBuilder = deviceAns_.toBuilder();
+              }
+              deviceAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(deviceAns_);
+                deviceAns_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000200;
+              break;
+            }
+            case 90: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000400) == 0x00000400)) {
+                subBuilder = deviceNtf_.toBuilder();
+              }
+              deviceNtf_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(deviceNtf_);
+                deviceNtf_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000400;
+              break;
+            }
+            case 98: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000800) == 0x00000800)) {
+                subBuilder = monitorReq_.toBuilder();
+              }
+              monitorReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(monitorReq_);
+                monitorReq_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000800;
+              break;
+            }
+            case 106: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder subBuilder = null;
+              if (((bitField0_ & 0x00001000) == 0x00001000)) {
+                subBuilder = monitorAns_.toBuilder();
+              }
+              monitorAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(monitorAns_);
+                monitorAns_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00001000;
+              break;
+            }
+            case 114: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder subBuilder = null;
+              if (((bitField0_ & 0x00002000) == 0x00002000)) {
+                subBuilder = monitorNtf_.toBuilder();
+              }
+              monitorNtf_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(monitorNtf_);
+                monitorNtf_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00002000;
+              break;
+            }
+            case 810: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder subBuilder = null;
+              if (((bitField0_ & 0x00004000) == 0x00004000)) {
+                subBuilder = nfcReq_.toBuilder();
+              }
+              nfcReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(nfcReq_);
+                nfcReq_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00004000;
+              break;
+            }
+            case 818: {
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder subBuilder = null;
+              if (((bitField0_ & 0x00008000) == 0x00008000)) {
+                subBuilder = nfcNtf_.toBuilder();
+              }
+              nfcNtf_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(nfcNtf_);
+                nfcNtf_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00008000;
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<Master> PARSER =
+        new com.google.protobuf.AbstractParser<Master>() {
+      public Master parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new Master(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<Master> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required .ECS.Master_Type type = 1;
+    public static final int TYPE_FIELD_NUMBER = 1;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type type_;
+    /**
+     * <code>required .ECS.Master_Type type = 1;</code>
+     */
+    public boolean hasType() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required .ECS.Master_Type type = 1;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type getType() {
+      return type_;
+    }
+
+    // optional .ECS.CheckVersionReq checkversion_req = 2;
+    public static final int CHECKVERSION_REQ_FIELD_NUMBER = 2;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq checkversionReq_;
+    /**
+     * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+     */
+    public boolean hasCheckversionReq() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq getCheckversionReq() {
+      return checkversionReq_;
+    }
+    /**
+     * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder getCheckversionReqOrBuilder() {
+      return checkversionReq_;
+    }
+
+    // optional .ECS.CheckVersionAns checkversion_ans = 3;
+    public static final int CHECKVERSION_ANS_FIELD_NUMBER = 3;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns checkversionAns_;
+    /**
+     * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+     */
+    public boolean hasCheckversionAns() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns getCheckversionAns() {
+      return checkversionAns_;
+    }
+    /**
+     * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder getCheckversionAnsOrBuilder() {
+      return checkversionAns_;
+    }
+
+    // optional .ECS.KeepAliveReq keepalive_req = 4;
+    public static final int KEEPALIVE_REQ_FIELD_NUMBER = 4;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq keepaliveReq_;
+    /**
+     * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+     */
+    public boolean hasKeepaliveReq() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq getKeepaliveReq() {
+      return keepaliveReq_;
+    }
+    /**
+     * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder getKeepaliveReqOrBuilder() {
+      return keepaliveReq_;
+    }
+
+    // optional .ECS.KeepAliveAns keepalive_ans = 5;
+    public static final int KEEPALIVE_ANS_FIELD_NUMBER = 5;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns keepaliveAns_;
+    /**
+     * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+     */
+    public boolean hasKeepaliveAns() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns getKeepaliveAns() {
+      return keepaliveAns_;
+    }
+    /**
+     * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder getKeepaliveAnsOrBuilder() {
+      return keepaliveAns_;
+    }
+
+    // optional .ECS.InjectorReq injector_req = 6;
+    public static final int INJECTOR_REQ_FIELD_NUMBER = 6;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq injectorReq_;
+    /**
+     * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+     */
+    public boolean hasInjectorReq() {
+      return ((bitField0_ & 0x00000020) == 0x00000020);
+    }
+    /**
+     * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq getInjectorReq() {
+      return injectorReq_;
+    }
+    /**
+     * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder getInjectorReqOrBuilder() {
+      return injectorReq_;
+    }
+
+    // optional .ECS.InjectorAns injector_ans = 7;
+    public static final int INJECTOR_ANS_FIELD_NUMBER = 7;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns injectorAns_;
+    /**
+     * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+     */
+    public boolean hasInjectorAns() {
+      return ((bitField0_ & 0x00000040) == 0x00000040);
+    }
+    /**
+     * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns getInjectorAns() {
+      return injectorAns_;
+    }
+    /**
+     * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder getInjectorAnsOrBuilder() {
+      return injectorAns_;
+    }
+
+    // optional .ECS.InjectorNtf injector_ntf = 8;
+    public static final int INJECTOR_NTF_FIELD_NUMBER = 8;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf injectorNtf_;
+    /**
+     * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+     */
+    public boolean hasInjectorNtf() {
+      return ((bitField0_ & 0x00000080) == 0x00000080);
+    }
+    /**
+     * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf getInjectorNtf() {
+      return injectorNtf_;
+    }
+    /**
+     * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder getInjectorNtfOrBuilder() {
+      return injectorNtf_;
+    }
+
+    // optional .ECS.DeviceReq device_req = 9;
+    public static final int DEVICE_REQ_FIELD_NUMBER = 9;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq deviceReq_;
+    /**
+     * <code>optional .ECS.DeviceReq device_req = 9;</code>
+     */
+    public boolean hasDeviceReq() {
+      return ((bitField0_ & 0x00000100) == 0x00000100);
+    }
+    /**
+     * <code>optional .ECS.DeviceReq device_req = 9;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq getDeviceReq() {
+      return deviceReq_;
+    }
+    /**
+     * <code>optional .ECS.DeviceReq device_req = 9;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder getDeviceReqOrBuilder() {
+      return deviceReq_;
+    }
+
+    // optional .ECS.DeviceAns device_ans = 10;
+    public static final int DEVICE_ANS_FIELD_NUMBER = 10;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns deviceAns_;
+    /**
+     * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+     */
+    public boolean hasDeviceAns() {
+      return ((bitField0_ & 0x00000200) == 0x00000200);
+    }
+    /**
+     * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns getDeviceAns() {
+      return deviceAns_;
+    }
+    /**
+     * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder getDeviceAnsOrBuilder() {
+      return deviceAns_;
+    }
+
+    // optional .ECS.DeviceNtf device_ntf = 11;
+    public static final int DEVICE_NTF_FIELD_NUMBER = 11;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf deviceNtf_;
+    /**
+     * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+     */
+    public boolean hasDeviceNtf() {
+      return ((bitField0_ & 0x00000400) == 0x00000400);
+    }
+    /**
+     * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf getDeviceNtf() {
+      return deviceNtf_;
+    }
+    /**
+     * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder getDeviceNtfOrBuilder() {
+      return deviceNtf_;
+    }
+
+    // optional .ECS.MonitorReq monitor_req = 12;
+    public static final int MONITOR_REQ_FIELD_NUMBER = 12;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq monitorReq_;
+    /**
+     * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+     */
+    public boolean hasMonitorReq() {
+      return ((bitField0_ & 0x00000800) == 0x00000800);
+    }
+    /**
+     * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq getMonitorReq() {
+      return monitorReq_;
+    }
+    /**
+     * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder getMonitorReqOrBuilder() {
+      return monitorReq_;
+    }
+
+    // optional .ECS.MonitorAns monitor_ans = 13;
+    public static final int MONITOR_ANS_FIELD_NUMBER = 13;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns monitorAns_;
+    /**
+     * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+     */
+    public boolean hasMonitorAns() {
+      return ((bitField0_ & 0x00001000) == 0x00001000);
+    }
+    /**
+     * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns getMonitorAns() {
+      return monitorAns_;
+    }
+    /**
+     * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder getMonitorAnsOrBuilder() {
+      return monitorAns_;
+    }
+
+    // optional .ECS.MonitorNtf monitor_ntf = 14;
+    public static final int MONITOR_NTF_FIELD_NUMBER = 14;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf monitorNtf_;
+    /**
+     * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+     */
+    public boolean hasMonitorNtf() {
+      return ((bitField0_ & 0x00002000) == 0x00002000);
+    }
+    /**
+     * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf getMonitorNtf() {
+      return monitorNtf_;
+    }
+    /**
+     * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder getMonitorNtfOrBuilder() {
+      return monitorNtf_;
+    }
+
+    // optional .ECS.NfcReq nfc_req = 101;
+    public static final int NFC_REQ_FIELD_NUMBER = 101;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq nfcReq_;
+    /**
+     * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+     *
+     * <pre>
+     * Extensions 101 to 150;
+     * </pre>
+     */
+    public boolean hasNfcReq() {
+      return ((bitField0_ & 0x00004000) == 0x00004000);
+    }
+    /**
+     * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+     *
+     * <pre>
+     * Extensions 101 to 150;
+     * </pre>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq getNfcReq() {
+      return nfcReq_;
+    }
+    /**
+     * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+     *
+     * <pre>
+     * Extensions 101 to 150;
+     * </pre>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder getNfcReqOrBuilder() {
+      return nfcReq_;
+    }
+
+    // optional .ECS.NfcNtf nfc_ntf = 102;
+    public static final int NFC_NTF_FIELD_NUMBER = 102;
+    private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf nfcNtf_;
+    /**
+     * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+     */
+    public boolean hasNfcNtf() {
+      return ((bitField0_ & 0x00008000) == 0x00008000);
+    }
+    /**
+     * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf getNfcNtf() {
+      return nfcNtf_;
+    }
+    /**
+     * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+     */
+    public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder getNfcNtfOrBuilder() {
+      return nfcNtf_;
+    }
+
+    private void initFields() {
+      type_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.CHECKVERSION_REQ;
+      checkversionReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance();
+      checkversionAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance();
+      keepaliveReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance();
+      keepaliveAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance();
+      injectorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance();
+      injectorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance();
+      injectorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance();
+      deviceReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance();
+      deviceAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance();
+      deviceNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance();
+      monitorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance();
+      monitorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance();
+      monitorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance();
+      nfcReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance();
+      nfcNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance();
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasType()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (hasCheckversionReq()) {
+        if (!getCheckversionReq().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasCheckversionAns()) {
+        if (!getCheckversionAns().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasInjectorReq()) {
+        if (!getInjectorReq().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasInjectorAns()) {
+        if (!getInjectorAns().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasInjectorNtf()) {
+        if (!getInjectorNtf().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasDeviceReq()) {
+        if (!getDeviceReq().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasDeviceAns()) {
+        if (!getDeviceAns().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasDeviceNtf()) {
+        if (!getDeviceNtf().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasMonitorReq()) {
+        if (!getMonitorReq().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasMonitorAns()) {
+        if (!getMonitorAns().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasMonitorNtf()) {
+        if (!getMonitorNtf().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasNfcReq()) {
+        if (!getNfcReq().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      if (hasNfcNtf()) {
+        if (!getNfcNtf().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeEnum(1, type_.getNumber());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeMessage(2, checkversionReq_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeMessage(3, checkversionAns_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeMessage(4, keepaliveReq_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        output.writeMessage(5, keepaliveAns_);
+      }
+      if (((bitField0_ & 0x00000020) == 0x00000020)) {
+        output.writeMessage(6, injectorReq_);
+      }
+      if (((bitField0_ & 0x00000040) == 0x00000040)) {
+        output.writeMessage(7, injectorAns_);
+      }
+      if (((bitField0_ & 0x00000080) == 0x00000080)) {
+        output.writeMessage(8, injectorNtf_);
+      }
+      if (((bitField0_ & 0x00000100) == 0x00000100)) {
+        output.writeMessage(9, deviceReq_);
+      }
+      if (((bitField0_ & 0x00000200) == 0x00000200)) {
+        output.writeMessage(10, deviceAns_);
+      }
+      if (((bitField0_ & 0x00000400) == 0x00000400)) {
+        output.writeMessage(11, deviceNtf_);
+      }
+      if (((bitField0_ & 0x00000800) == 0x00000800)) {
+        output.writeMessage(12, monitorReq_);
+      }
+      if (((bitField0_ & 0x00001000) == 0x00001000)) {
+        output.writeMessage(13, monitorAns_);
+      }
+      if (((bitField0_ & 0x00002000) == 0x00002000)) {
+        output.writeMessage(14, monitorNtf_);
+      }
+      if (((bitField0_ & 0x00004000) == 0x00004000)) {
+        output.writeMessage(101, nfcReq_);
+      }
+      if (((bitField0_ & 0x00008000) == 0x00008000)) {
+        output.writeMessage(102, nfcNtf_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeEnumSize(1, type_.getNumber());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(2, checkversionReq_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(3, checkversionAns_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(4, keepaliveReq_);
+      }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(5, keepaliveAns_);
+      }
+      if (((bitField0_ & 0x00000020) == 0x00000020)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(6, injectorReq_);
+      }
+      if (((bitField0_ & 0x00000040) == 0x00000040)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(7, injectorAns_);
+      }
+      if (((bitField0_ & 0x00000080) == 0x00000080)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(8, injectorNtf_);
+      }
+      if (((bitField0_ & 0x00000100) == 0x00000100)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(9, deviceReq_);
+      }
+      if (((bitField0_ & 0x00000200) == 0x00000200)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(10, deviceAns_);
+      }
+      if (((bitField0_ & 0x00000400) == 0x00000400)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(11, deviceNtf_);
+      }
+      if (((bitField0_ & 0x00000800) == 0x00000800)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(12, monitorReq_);
+      }
+      if (((bitField0_ & 0x00001000) == 0x00001000)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(13, monitorAns_);
+      }
+      if (((bitField0_ & 0x00002000) == 0x00002000)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(14, monitorNtf_);
+      }
+      if (((bitField0_ & 0x00004000) == 0x00004000)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(101, nfcReq_);
+      }
+      if (((bitField0_ & 0x00008000) == 0x00008000)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(102, nfcNtf_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ECS.Master}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MasterOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.Builder.class);
+      }
+
+      // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+          getCheckversionReqFieldBuilder();
+          getCheckversionAnsFieldBuilder();
+          getKeepaliveReqFieldBuilder();
+          getKeepaliveAnsFieldBuilder();
+          getInjectorReqFieldBuilder();
+          getInjectorAnsFieldBuilder();
+          getInjectorNtfFieldBuilder();
+          getDeviceReqFieldBuilder();
+          getDeviceAnsFieldBuilder();
+          getDeviceNtfFieldBuilder();
+          getMonitorReqFieldBuilder();
+          getMonitorAnsFieldBuilder();
+          getMonitorNtfFieldBuilder();
+          getNfcReqFieldBuilder();
+          getNfcNtfFieldBuilder();
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        type_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.CHECKVERSION_REQ;
+        bitField0_ = (bitField0_ & ~0x00000001);
+        if (checkversionReqBuilder_ == null) {
+          checkversionReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance();
+        } else {
+          checkversionReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000002);
+        if (checkversionAnsBuilder_ == null) {
+          checkversionAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance();
+        } else {
+          checkversionAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000004);
+        if (keepaliveReqBuilder_ == null) {
+          keepaliveReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance();
+        } else {
+          keepaliveReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000008);
+        if (keepaliveAnsBuilder_ == null) {
+          keepaliveAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance();
+        } else {
+          keepaliveAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000010);
+        if (injectorReqBuilder_ == null) {
+          injectorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance();
+        } else {
+          injectorReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000020);
+        if (injectorAnsBuilder_ == null) {
+          injectorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance();
+        } else {
+          injectorAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000040);
+        if (injectorNtfBuilder_ == null) {
+          injectorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance();
+        } else {
+          injectorNtfBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000080);
+        if (deviceReqBuilder_ == null) {
+          deviceReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance();
+        } else {
+          deviceReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000100);
+        if (deviceAnsBuilder_ == null) {
+          deviceAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance();
+        } else {
+          deviceAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000200);
+        if (deviceNtfBuilder_ == null) {
+          deviceNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance();
+        } else {
+          deviceNtfBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000400);
+        if (monitorReqBuilder_ == null) {
+          monitorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance();
+        } else {
+          monitorReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000800);
+        if (monitorAnsBuilder_ == null) {
+          monitorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance();
+        } else {
+          monitorAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00001000);
+        if (monitorNtfBuilder_ == null) {
+          monitorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance();
+        } else {
+          monitorNtfBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00002000);
+        if (nfcReqBuilder_ == null) {
+          nfcReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance();
+        } else {
+          nfcReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00004000);
+        if (nfcNtfBuilder_ == null) {
+          nfcNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance();
+        } else {
+          nfcNtfBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00008000);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_descriptor;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master getDefaultInstanceForType() {
+        return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.getDefaultInstance();
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master build() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master buildPartial() {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.type_ = type_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        if (checkversionReqBuilder_ == null) {
+          result.checkversionReq_ = checkversionReq_;
+        } else {
+          result.checkversionReq_ = checkversionReqBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        if (checkversionAnsBuilder_ == null) {
+          result.checkversionAns_ = checkversionAns_;
+        } else {
+          result.checkversionAns_ = checkversionAnsBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        if (keepaliveReqBuilder_ == null) {
+          result.keepaliveReq_ = keepaliveReq_;
+        } else {
+          result.keepaliveReq_ = keepaliveReqBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+          to_bitField0_ |= 0x00000010;
+        }
+        if (keepaliveAnsBuilder_ == null) {
+          result.keepaliveAns_ = keepaliveAns_;
+        } else {
+          result.keepaliveAns_ = keepaliveAnsBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+          to_bitField0_ |= 0x00000020;
+        }
+        if (injectorReqBuilder_ == null) {
+          result.injectorReq_ = injectorReq_;
+        } else {
+          result.injectorReq_ = injectorReqBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
+          to_bitField0_ |= 0x00000040;
+        }
+        if (injectorAnsBuilder_ == null) {
+          result.injectorAns_ = injectorAns_;
+        } else {
+          result.injectorAns_ = injectorAnsBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
+          to_bitField0_ |= 0x00000080;
+        }
+        if (injectorNtfBuilder_ == null) {
+          result.injectorNtf_ = injectorNtf_;
+        } else {
+          result.injectorNtf_ = injectorNtfBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
+          to_bitField0_ |= 0x00000100;
+        }
+        if (deviceReqBuilder_ == null) {
+          result.deviceReq_ = deviceReq_;
+        } else {
+          result.deviceReq_ = deviceReqBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
+          to_bitField0_ |= 0x00000200;
+        }
+        if (deviceAnsBuilder_ == null) {
+          result.deviceAns_ = deviceAns_;
+        } else {
+          result.deviceAns_ = deviceAnsBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000400) == 0x00000400)) {
+          to_bitField0_ |= 0x00000400;
+        }
+        if (deviceNtfBuilder_ == null) {
+          result.deviceNtf_ = deviceNtf_;
+        } else {
+          result.deviceNtf_ = deviceNtfBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000800) == 0x00000800)) {
+          to_bitField0_ |= 0x00000800;
+        }
+        if (monitorReqBuilder_ == null) {
+          result.monitorReq_ = monitorReq_;
+        } else {
+          result.monitorReq_ = monitorReqBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00001000) == 0x00001000)) {
+          to_bitField0_ |= 0x00001000;
+        }
+        if (monitorAnsBuilder_ == null) {
+          result.monitorAns_ = monitorAns_;
+        } else {
+          result.monitorAns_ = monitorAnsBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00002000) == 0x00002000)) {
+          to_bitField0_ |= 0x00002000;
+        }
+        if (monitorNtfBuilder_ == null) {
+          result.monitorNtf_ = monitorNtf_;
+        } else {
+          result.monitorNtf_ = monitorNtfBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00004000) == 0x00004000)) {
+          to_bitField0_ |= 0x00004000;
+        }
+        if (nfcReqBuilder_ == null) {
+          result.nfcReq_ = nfcReq_;
+        } else {
+          result.nfcReq_ = nfcReqBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00008000) == 0x00008000)) {
+          to_bitField0_ |= 0x00008000;
+        }
+        if (nfcNtfBuilder_ == null) {
+          result.nfcNtf_ = nfcNtf_;
+        } else {
+          result.nfcNtf_ = nfcNtfBuilder_.build();
+        }
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master) {
+          return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master other) {
+        if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.getDefaultInstance()) return this;
+        if (other.hasType()) {
+          setType(other.getType());
+        }
+        if (other.hasCheckversionReq()) {
+          mergeCheckversionReq(other.getCheckversionReq());
+        }
+        if (other.hasCheckversionAns()) {
+          mergeCheckversionAns(other.getCheckversionAns());
+        }
+        if (other.hasKeepaliveReq()) {
+          mergeKeepaliveReq(other.getKeepaliveReq());
+        }
+        if (other.hasKeepaliveAns()) {
+          mergeKeepaliveAns(other.getKeepaliveAns());
+        }
+        if (other.hasInjectorReq()) {
+          mergeInjectorReq(other.getInjectorReq());
+        }
+        if (other.hasInjectorAns()) {
+          mergeInjectorAns(other.getInjectorAns());
+        }
+        if (other.hasInjectorNtf()) {
+          mergeInjectorNtf(other.getInjectorNtf());
+        }
+        if (other.hasDeviceReq()) {
+          mergeDeviceReq(other.getDeviceReq());
+        }
+        if (other.hasDeviceAns()) {
+          mergeDeviceAns(other.getDeviceAns());
+        }
+        if (other.hasDeviceNtf()) {
+          mergeDeviceNtf(other.getDeviceNtf());
+        }
+        if (other.hasMonitorReq()) {
+          mergeMonitorReq(other.getMonitorReq());
+        }
+        if (other.hasMonitorAns()) {
+          mergeMonitorAns(other.getMonitorAns());
+        }
+        if (other.hasMonitorNtf()) {
+          mergeMonitorNtf(other.getMonitorNtf());
+        }
+        if (other.hasNfcReq()) {
+          mergeNfcReq(other.getNfcReq());
+        }
+        if (other.hasNfcNtf()) {
+          mergeNfcNtf(other.getNfcNtf());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasType()) {
+          
+          return false;
+        }
+        if (hasCheckversionReq()) {
+          if (!getCheckversionReq().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasCheckversionAns()) {
+          if (!getCheckversionAns().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasInjectorReq()) {
+          if (!getInjectorReq().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasInjectorAns()) {
+          if (!getInjectorAns().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasInjectorNtf()) {
+          if (!getInjectorNtf().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasDeviceReq()) {
+          if (!getDeviceReq().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasDeviceAns()) {
+          if (!getDeviceAns().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasDeviceNtf()) {
+          if (!getDeviceNtf().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasMonitorReq()) {
+          if (!getMonitorReq().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasMonitorAns()) {
+          if (!getMonitorAns().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasMonitorNtf()) {
+          if (!getMonitorNtf().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasNfcReq()) {
+          if (!getNfcReq().isInitialized()) {
+            
+            return false;
+          }
+        }
+        if (hasNfcNtf()) {
+          if (!getNfcNtf().isInitialized()) {
+            
+            return false;
+          }
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required .ECS.Master_Type type = 1;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type type_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.CHECKVERSION_REQ;
+      /**
+       * <code>required .ECS.Master_Type type = 1;</code>
+       */
+      public boolean hasType() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required .ECS.Master_Type type = 1;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type getType() {
+        return type_;
+      }
+      /**
+       * <code>required .ECS.Master_Type type = 1;</code>
+       */
+      public Builder setType(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        bitField0_ |= 0x00000001;
+        type_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required .ECS.Master_Type type = 1;</code>
+       */
+      public Builder clearType() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        type_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.CHECKVERSION_REQ;
+        onChanged();
+        return this;
+      }
+
+      // optional .ECS.CheckVersionReq checkversion_req = 2;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq checkversionReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder> checkversionReqBuilder_;
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      public boolean hasCheckversionReq() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq getCheckversionReq() {
+        if (checkversionReqBuilder_ == null) {
+          return checkversionReq_;
+        } else {
+          return checkversionReqBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      public Builder setCheckversionReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq value) {
+        if (checkversionReqBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          checkversionReq_ = value;
+          onChanged();
+        } else {
+          checkversionReqBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000002;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      public Builder setCheckversionReq(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder builderForValue) {
+        if (checkversionReqBuilder_ == null) {
+          checkversionReq_ = builderForValue.build();
+          onChanged();
+        } else {
+          checkversionReqBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000002;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      public Builder mergeCheckversionReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq value) {
+        if (checkversionReqBuilder_ == null) {
+          if (((bitField0_ & 0x00000002) == 0x00000002) &&
+              checkversionReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance()) {
+            checkversionReq_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.newBuilder(checkversionReq_).mergeFrom(value).buildPartial();
+          } else {
+            checkversionReq_ = value;
+          }
+          onChanged();
+        } else {
+          checkversionReqBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000002;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      public Builder clearCheckversionReq() {
+        if (checkversionReqBuilder_ == null) {
+          checkversionReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance();
+          onChanged();
+        } else {
+          checkversionReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder getCheckversionReqBuilder() {
+        bitField0_ |= 0x00000002;
+        onChanged();
+        return getCheckversionReqFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder getCheckversionReqOrBuilder() {
+        if (checkversionReqBuilder_ != null) {
+          return checkversionReqBuilder_.getMessageOrBuilder();
+        } else {
+          return checkversionReq_;
+        }
+      }
+      /**
+       * <code>optional .ECS.CheckVersionReq checkversion_req = 2;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder> 
+          getCheckversionReqFieldBuilder() {
+        if (checkversionReqBuilder_ == null) {
+          checkversionReqBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder>(
+                  checkversionReq_,
+                  getParentForChildren(),
+                  isClean());
+          checkversionReq_ = null;
+        }
+        return checkversionReqBuilder_;
+      }
+
+      // optional .ECS.CheckVersionAns checkversion_ans = 3;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns checkversionAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder> checkversionAnsBuilder_;
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      public boolean hasCheckversionAns() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns getCheckversionAns() {
+        if (checkversionAnsBuilder_ == null) {
+          return checkversionAns_;
+        } else {
+          return checkversionAnsBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      public Builder setCheckversionAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns value) {
+        if (checkversionAnsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          checkversionAns_ = value;
+          onChanged();
+        } else {
+          checkversionAnsBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      public Builder setCheckversionAns(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder builderForValue) {
+        if (checkversionAnsBuilder_ == null) {
+          checkversionAns_ = builderForValue.build();
+          onChanged();
+        } else {
+          checkversionAnsBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      public Builder mergeCheckversionAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns value) {
+        if (checkversionAnsBuilder_ == null) {
+          if (((bitField0_ & 0x00000004) == 0x00000004) &&
+              checkversionAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance()) {
+            checkversionAns_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.newBuilder(checkversionAns_).mergeFrom(value).buildPartial();
+          } else {
+            checkversionAns_ = value;
+          }
+          onChanged();
+        } else {
+          checkversionAnsBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      public Builder clearCheckversionAns() {
+        if (checkversionAnsBuilder_ == null) {
+          checkversionAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance();
+          onChanged();
+        } else {
+          checkversionAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder getCheckversionAnsBuilder() {
+        bitField0_ |= 0x00000004;
+        onChanged();
+        return getCheckversionAnsFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder getCheckversionAnsOrBuilder() {
+        if (checkversionAnsBuilder_ != null) {
+          return checkversionAnsBuilder_.getMessageOrBuilder();
+        } else {
+          return checkversionAns_;
+        }
+      }
+      /**
+       * <code>optional .ECS.CheckVersionAns checkversion_ans = 3;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder> 
+          getCheckversionAnsFieldBuilder() {
+        if (checkversionAnsBuilder_ == null) {
+          checkversionAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder>(
+                  checkversionAns_,
+                  getParentForChildren(),
+                  isClean());
+          checkversionAns_ = null;
+        }
+        return checkversionAnsBuilder_;
+      }
+
+      // optional .ECS.KeepAliveReq keepalive_req = 4;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq keepaliveReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder> keepaliveReqBuilder_;
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      public boolean hasKeepaliveReq() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq getKeepaliveReq() {
+        if (keepaliveReqBuilder_ == null) {
+          return keepaliveReq_;
+        } else {
+          return keepaliveReqBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      public Builder setKeepaliveReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq value) {
+        if (keepaliveReqBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          keepaliveReq_ = value;
+          onChanged();
+        } else {
+          keepaliveReqBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000008;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      public Builder setKeepaliveReq(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder builderForValue) {
+        if (keepaliveReqBuilder_ == null) {
+          keepaliveReq_ = builderForValue.build();
+          onChanged();
+        } else {
+          keepaliveReqBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000008;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      public Builder mergeKeepaliveReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq value) {
+        if (keepaliveReqBuilder_ == null) {
+          if (((bitField0_ & 0x00000008) == 0x00000008) &&
+              keepaliveReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance()) {
+            keepaliveReq_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.newBuilder(keepaliveReq_).mergeFrom(value).buildPartial();
+          } else {
+            keepaliveReq_ = value;
+          }
+          onChanged();
+        } else {
+          keepaliveReqBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000008;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      public Builder clearKeepaliveReq() {
+        if (keepaliveReqBuilder_ == null) {
+          keepaliveReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance();
+          onChanged();
+        } else {
+          keepaliveReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000008);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder getKeepaliveReqBuilder() {
+        bitField0_ |= 0x00000008;
+        onChanged();
+        return getKeepaliveReqFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder getKeepaliveReqOrBuilder() {
+        if (keepaliveReqBuilder_ != null) {
+          return keepaliveReqBuilder_.getMessageOrBuilder();
+        } else {
+          return keepaliveReq_;
+        }
+      }
+      /**
+       * <code>optional .ECS.KeepAliveReq keepalive_req = 4;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder> 
+          getKeepaliveReqFieldBuilder() {
+        if (keepaliveReqBuilder_ == null) {
+          keepaliveReqBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder>(
+                  keepaliveReq_,
+                  getParentForChildren(),
+                  isClean());
+          keepaliveReq_ = null;
+        }
+        return keepaliveReqBuilder_;
+      }
+
+      // optional .ECS.KeepAliveAns keepalive_ans = 5;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns keepaliveAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder> keepaliveAnsBuilder_;
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      public boolean hasKeepaliveAns() {
+        return ((bitField0_ & 0x00000010) == 0x00000010);
+      }
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns getKeepaliveAns() {
+        if (keepaliveAnsBuilder_ == null) {
+          return keepaliveAns_;
+        } else {
+          return keepaliveAnsBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      public Builder setKeepaliveAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns value) {
+        if (keepaliveAnsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          keepaliveAns_ = value;
+          onChanged();
+        } else {
+          keepaliveAnsBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000010;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      public Builder setKeepaliveAns(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder builderForValue) {
+        if (keepaliveAnsBuilder_ == null) {
+          keepaliveAns_ = builderForValue.build();
+          onChanged();
+        } else {
+          keepaliveAnsBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000010;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      public Builder mergeKeepaliveAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns value) {
+        if (keepaliveAnsBuilder_ == null) {
+          if (((bitField0_ & 0x00000010) == 0x00000010) &&
+              keepaliveAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance()) {
+            keepaliveAns_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.newBuilder(keepaliveAns_).mergeFrom(value).buildPartial();
+          } else {
+            keepaliveAns_ = value;
+          }
+          onChanged();
+        } else {
+          keepaliveAnsBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000010;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      public Builder clearKeepaliveAns() {
+        if (keepaliveAnsBuilder_ == null) {
+          keepaliveAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance();
+          onChanged();
+        } else {
+          keepaliveAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000010);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder getKeepaliveAnsBuilder() {
+        bitField0_ |= 0x00000010;
+        onChanged();
+        return getKeepaliveAnsFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder getKeepaliveAnsOrBuilder() {
+        if (keepaliveAnsBuilder_ != null) {
+          return keepaliveAnsBuilder_.getMessageOrBuilder();
+        } else {
+          return keepaliveAns_;
+        }
+      }
+      /**
+       * <code>optional .ECS.KeepAliveAns keepalive_ans = 5;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder> 
+          getKeepaliveAnsFieldBuilder() {
+        if (keepaliveAnsBuilder_ == null) {
+          keepaliveAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder>(
+                  keepaliveAns_,
+                  getParentForChildren(),
+                  isClean());
+          keepaliveAns_ = null;
+        }
+        return keepaliveAnsBuilder_;
+      }
+
+      // optional .ECS.InjectorReq injector_req = 6;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq injectorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder> injectorReqBuilder_;
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      public boolean hasInjectorReq() {
+        return ((bitField0_ & 0x00000020) == 0x00000020);
+      }
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq getInjectorReq() {
+        if (injectorReqBuilder_ == null) {
+          return injectorReq_;
+        } else {
+          return injectorReqBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      public Builder setInjectorReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq value) {
+        if (injectorReqBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          injectorReq_ = value;
+          onChanged();
+        } else {
+          injectorReqBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000020;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      public Builder setInjectorReq(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder builderForValue) {
+        if (injectorReqBuilder_ == null) {
+          injectorReq_ = builderForValue.build();
+          onChanged();
+        } else {
+          injectorReqBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000020;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      public Builder mergeInjectorReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq value) {
+        if (injectorReqBuilder_ == null) {
+          if (((bitField0_ & 0x00000020) == 0x00000020) &&
+              injectorReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance()) {
+            injectorReq_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.newBuilder(injectorReq_).mergeFrom(value).buildPartial();
+          } else {
+            injectorReq_ = value;
+          }
+          onChanged();
+        } else {
+          injectorReqBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000020;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      public Builder clearInjectorReq() {
+        if (injectorReqBuilder_ == null) {
+          injectorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance();
+          onChanged();
+        } else {
+          injectorReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000020);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder getInjectorReqBuilder() {
+        bitField0_ |= 0x00000020;
+        onChanged();
+        return getInjectorReqFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder getInjectorReqOrBuilder() {
+        if (injectorReqBuilder_ != null) {
+          return injectorReqBuilder_.getMessageOrBuilder();
+        } else {
+          return injectorReq_;
+        }
+      }
+      /**
+       * <code>optional .ECS.InjectorReq injector_req = 6;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder> 
+          getInjectorReqFieldBuilder() {
+        if (injectorReqBuilder_ == null) {
+          injectorReqBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder>(
+                  injectorReq_,
+                  getParentForChildren(),
+                  isClean());
+          injectorReq_ = null;
+        }
+        return injectorReqBuilder_;
+      }
+
+      // optional .ECS.InjectorAns injector_ans = 7;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns injectorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder> injectorAnsBuilder_;
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      public boolean hasInjectorAns() {
+        return ((bitField0_ & 0x00000040) == 0x00000040);
+      }
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns getInjectorAns() {
+        if (injectorAnsBuilder_ == null) {
+          return injectorAns_;
+        } else {
+          return injectorAnsBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      public Builder setInjectorAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns value) {
+        if (injectorAnsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          injectorAns_ = value;
+          onChanged();
+        } else {
+          injectorAnsBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000040;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      public Builder setInjectorAns(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder builderForValue) {
+        if (injectorAnsBuilder_ == null) {
+          injectorAns_ = builderForValue.build();
+          onChanged();
+        } else {
+          injectorAnsBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000040;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      public Builder mergeInjectorAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns value) {
+        if (injectorAnsBuilder_ == null) {
+          if (((bitField0_ & 0x00000040) == 0x00000040) &&
+              injectorAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance()) {
+            injectorAns_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.newBuilder(injectorAns_).mergeFrom(value).buildPartial();
+          } else {
+            injectorAns_ = value;
+          }
+          onChanged();
+        } else {
+          injectorAnsBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000040;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      public Builder clearInjectorAns() {
+        if (injectorAnsBuilder_ == null) {
+          injectorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance();
+          onChanged();
+        } else {
+          injectorAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000040);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder getInjectorAnsBuilder() {
+        bitField0_ |= 0x00000040;
+        onChanged();
+        return getInjectorAnsFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder getInjectorAnsOrBuilder() {
+        if (injectorAnsBuilder_ != null) {
+          return injectorAnsBuilder_.getMessageOrBuilder();
+        } else {
+          return injectorAns_;
+        }
+      }
+      /**
+       * <code>optional .ECS.InjectorAns injector_ans = 7;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder> 
+          getInjectorAnsFieldBuilder() {
+        if (injectorAnsBuilder_ == null) {
+          injectorAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder>(
+                  injectorAns_,
+                  getParentForChildren(),
+                  isClean());
+          injectorAns_ = null;
+        }
+        return injectorAnsBuilder_;
+      }
+
+      // optional .ECS.InjectorNtf injector_ntf = 8;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf injectorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder> injectorNtfBuilder_;
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      public boolean hasInjectorNtf() {
+        return ((bitField0_ & 0x00000080) == 0x00000080);
+      }
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf getInjectorNtf() {
+        if (injectorNtfBuilder_ == null) {
+          return injectorNtf_;
+        } else {
+          return injectorNtfBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      public Builder setInjectorNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf value) {
+        if (injectorNtfBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          injectorNtf_ = value;
+          onChanged();
+        } else {
+          injectorNtfBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000080;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      public Builder setInjectorNtf(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder builderForValue) {
+        if (injectorNtfBuilder_ == null) {
+          injectorNtf_ = builderForValue.build();
+          onChanged();
+        } else {
+          injectorNtfBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000080;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      public Builder mergeInjectorNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf value) {
+        if (injectorNtfBuilder_ == null) {
+          if (((bitField0_ & 0x00000080) == 0x00000080) &&
+              injectorNtf_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance()) {
+            injectorNtf_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.newBuilder(injectorNtf_).mergeFrom(value).buildPartial();
+          } else {
+            injectorNtf_ = value;
+          }
+          onChanged();
+        } else {
+          injectorNtfBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000080;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      public Builder clearInjectorNtf() {
+        if (injectorNtfBuilder_ == null) {
+          injectorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance();
+          onChanged();
+        } else {
+          injectorNtfBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000080);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder getInjectorNtfBuilder() {
+        bitField0_ |= 0x00000080;
+        onChanged();
+        return getInjectorNtfFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder getInjectorNtfOrBuilder() {
+        if (injectorNtfBuilder_ != null) {
+          return injectorNtfBuilder_.getMessageOrBuilder();
+        } else {
+          return injectorNtf_;
+        }
+      }
+      /**
+       * <code>optional .ECS.InjectorNtf injector_ntf = 8;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder> 
+          getInjectorNtfFieldBuilder() {
+        if (injectorNtfBuilder_ == null) {
+          injectorNtfBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder>(
+                  injectorNtf_,
+                  getParentForChildren(),
+                  isClean());
+          injectorNtf_ = null;
+        }
+        return injectorNtfBuilder_;
+      }
+
+      // optional .ECS.DeviceReq device_req = 9;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq deviceReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder> deviceReqBuilder_;
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      public boolean hasDeviceReq() {
+        return ((bitField0_ & 0x00000100) == 0x00000100);
+      }
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq getDeviceReq() {
+        if (deviceReqBuilder_ == null) {
+          return deviceReq_;
+        } else {
+          return deviceReqBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      public Builder setDeviceReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq value) {
+        if (deviceReqBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          deviceReq_ = value;
+          onChanged();
+        } else {
+          deviceReqBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000100;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      public Builder setDeviceReq(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder builderForValue) {
+        if (deviceReqBuilder_ == null) {
+          deviceReq_ = builderForValue.build();
+          onChanged();
+        } else {
+          deviceReqBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000100;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      public Builder mergeDeviceReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq value) {
+        if (deviceReqBuilder_ == null) {
+          if (((bitField0_ & 0x00000100) == 0x00000100) &&
+              deviceReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance()) {
+            deviceReq_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.newBuilder(deviceReq_).mergeFrom(value).buildPartial();
+          } else {
+            deviceReq_ = value;
+          }
+          onChanged();
+        } else {
+          deviceReqBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000100;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      public Builder clearDeviceReq() {
+        if (deviceReqBuilder_ == null) {
+          deviceReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance();
+          onChanged();
+        } else {
+          deviceReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000100);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder getDeviceReqBuilder() {
+        bitField0_ |= 0x00000100;
+        onChanged();
+        return getDeviceReqFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder getDeviceReqOrBuilder() {
+        if (deviceReqBuilder_ != null) {
+          return deviceReqBuilder_.getMessageOrBuilder();
+        } else {
+          return deviceReq_;
+        }
+      }
+      /**
+       * <code>optional .ECS.DeviceReq device_req = 9;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder> 
+          getDeviceReqFieldBuilder() {
+        if (deviceReqBuilder_ == null) {
+          deviceReqBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder>(
+                  deviceReq_,
+                  getParentForChildren(),
+                  isClean());
+          deviceReq_ = null;
+        }
+        return deviceReqBuilder_;
+      }
+
+      // optional .ECS.DeviceAns device_ans = 10;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns deviceAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder> deviceAnsBuilder_;
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      public boolean hasDeviceAns() {
+        return ((bitField0_ & 0x00000200) == 0x00000200);
+      }
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns getDeviceAns() {
+        if (deviceAnsBuilder_ == null) {
+          return deviceAns_;
+        } else {
+          return deviceAnsBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      public Builder setDeviceAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns value) {
+        if (deviceAnsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          deviceAns_ = value;
+          onChanged();
+        } else {
+          deviceAnsBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000200;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      public Builder setDeviceAns(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder builderForValue) {
+        if (deviceAnsBuilder_ == null) {
+          deviceAns_ = builderForValue.build();
+          onChanged();
+        } else {
+          deviceAnsBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000200;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      public Builder mergeDeviceAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns value) {
+        if (deviceAnsBuilder_ == null) {
+          if (((bitField0_ & 0x00000200) == 0x00000200) &&
+              deviceAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance()) {
+            deviceAns_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.newBuilder(deviceAns_).mergeFrom(value).buildPartial();
+          } else {
+            deviceAns_ = value;
+          }
+          onChanged();
+        } else {
+          deviceAnsBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000200;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      public Builder clearDeviceAns() {
+        if (deviceAnsBuilder_ == null) {
+          deviceAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance();
+          onChanged();
+        } else {
+          deviceAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000200);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder getDeviceAnsBuilder() {
+        bitField0_ |= 0x00000200;
+        onChanged();
+        return getDeviceAnsFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder getDeviceAnsOrBuilder() {
+        if (deviceAnsBuilder_ != null) {
+          return deviceAnsBuilder_.getMessageOrBuilder();
+        } else {
+          return deviceAns_;
+        }
+      }
+      /**
+       * <code>optional .ECS.DeviceAns device_ans = 10;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder> 
+          getDeviceAnsFieldBuilder() {
+        if (deviceAnsBuilder_ == null) {
+          deviceAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder>(
+                  deviceAns_,
+                  getParentForChildren(),
+                  isClean());
+          deviceAns_ = null;
+        }
+        return deviceAnsBuilder_;
+      }
+
+      // optional .ECS.DeviceNtf device_ntf = 11;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf deviceNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder> deviceNtfBuilder_;
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      public boolean hasDeviceNtf() {
+        return ((bitField0_ & 0x00000400) == 0x00000400);
+      }
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf getDeviceNtf() {
+        if (deviceNtfBuilder_ == null) {
+          return deviceNtf_;
+        } else {
+          return deviceNtfBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      public Builder setDeviceNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf value) {
+        if (deviceNtfBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          deviceNtf_ = value;
+          onChanged();
+        } else {
+          deviceNtfBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000400;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      public Builder setDeviceNtf(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder builderForValue) {
+        if (deviceNtfBuilder_ == null) {
+          deviceNtf_ = builderForValue.build();
+          onChanged();
+        } else {
+          deviceNtfBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000400;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      public Builder mergeDeviceNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf value) {
+        if (deviceNtfBuilder_ == null) {
+          if (((bitField0_ & 0x00000400) == 0x00000400) &&
+              deviceNtf_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance()) {
+            deviceNtf_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.newBuilder(deviceNtf_).mergeFrom(value).buildPartial();
+          } else {
+            deviceNtf_ = value;
+          }
+          onChanged();
+        } else {
+          deviceNtfBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000400;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      public Builder clearDeviceNtf() {
+        if (deviceNtfBuilder_ == null) {
+          deviceNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance();
+          onChanged();
+        } else {
+          deviceNtfBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000400);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder getDeviceNtfBuilder() {
+        bitField0_ |= 0x00000400;
+        onChanged();
+        return getDeviceNtfFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder getDeviceNtfOrBuilder() {
+        if (deviceNtfBuilder_ != null) {
+          return deviceNtfBuilder_.getMessageOrBuilder();
+        } else {
+          return deviceNtf_;
+        }
+      }
+      /**
+       * <code>optional .ECS.DeviceNtf device_ntf = 11;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder> 
+          getDeviceNtfFieldBuilder() {
+        if (deviceNtfBuilder_ == null) {
+          deviceNtfBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder>(
+                  deviceNtf_,
+                  getParentForChildren(),
+                  isClean());
+          deviceNtf_ = null;
+        }
+        return deviceNtfBuilder_;
+      }
+
+      // optional .ECS.MonitorReq monitor_req = 12;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq monitorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder> monitorReqBuilder_;
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      public boolean hasMonitorReq() {
+        return ((bitField0_ & 0x00000800) == 0x00000800);
+      }
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq getMonitorReq() {
+        if (monitorReqBuilder_ == null) {
+          return monitorReq_;
+        } else {
+          return monitorReqBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      public Builder setMonitorReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq value) {
+        if (monitorReqBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          monitorReq_ = value;
+          onChanged();
+        } else {
+          monitorReqBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000800;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      public Builder setMonitorReq(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder builderForValue) {
+        if (monitorReqBuilder_ == null) {
+          monitorReq_ = builderForValue.build();
+          onChanged();
+        } else {
+          monitorReqBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000800;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      public Builder mergeMonitorReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq value) {
+        if (monitorReqBuilder_ == null) {
+          if (((bitField0_ & 0x00000800) == 0x00000800) &&
+              monitorReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance()) {
+            monitorReq_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.newBuilder(monitorReq_).mergeFrom(value).buildPartial();
+          } else {
+            monitorReq_ = value;
+          }
+          onChanged();
+        } else {
+          monitorReqBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000800;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      public Builder clearMonitorReq() {
+        if (monitorReqBuilder_ == null) {
+          monitorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance();
+          onChanged();
+        } else {
+          monitorReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000800);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder getMonitorReqBuilder() {
+        bitField0_ |= 0x00000800;
+        onChanged();
+        return getMonitorReqFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder getMonitorReqOrBuilder() {
+        if (monitorReqBuilder_ != null) {
+          return monitorReqBuilder_.getMessageOrBuilder();
+        } else {
+          return monitorReq_;
+        }
+      }
+      /**
+       * <code>optional .ECS.MonitorReq monitor_req = 12;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder> 
+          getMonitorReqFieldBuilder() {
+        if (monitorReqBuilder_ == null) {
+          monitorReqBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder>(
+                  monitorReq_,
+                  getParentForChildren(),
+                  isClean());
+          monitorReq_ = null;
+        }
+        return monitorReqBuilder_;
+      }
+
+      // optional .ECS.MonitorAns monitor_ans = 13;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns monitorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder> monitorAnsBuilder_;
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      public boolean hasMonitorAns() {
+        return ((bitField0_ & 0x00001000) == 0x00001000);
+      }
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns getMonitorAns() {
+        if (monitorAnsBuilder_ == null) {
+          return monitorAns_;
+        } else {
+          return monitorAnsBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      public Builder setMonitorAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns value) {
+        if (monitorAnsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          monitorAns_ = value;
+          onChanged();
+        } else {
+          monitorAnsBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00001000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      public Builder setMonitorAns(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder builderForValue) {
+        if (monitorAnsBuilder_ == null) {
+          monitorAns_ = builderForValue.build();
+          onChanged();
+        } else {
+          monitorAnsBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00001000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      public Builder mergeMonitorAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns value) {
+        if (monitorAnsBuilder_ == null) {
+          if (((bitField0_ & 0x00001000) == 0x00001000) &&
+              monitorAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance()) {
+            monitorAns_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.newBuilder(monitorAns_).mergeFrom(value).buildPartial();
+          } else {
+            monitorAns_ = value;
+          }
+          onChanged();
+        } else {
+          monitorAnsBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00001000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      public Builder clearMonitorAns() {
+        if (monitorAnsBuilder_ == null) {
+          monitorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance();
+          onChanged();
+        } else {
+          monitorAnsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00001000);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder getMonitorAnsBuilder() {
+        bitField0_ |= 0x00001000;
+        onChanged();
+        return getMonitorAnsFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder getMonitorAnsOrBuilder() {
+        if (monitorAnsBuilder_ != null) {
+          return monitorAnsBuilder_.getMessageOrBuilder();
+        } else {
+          return monitorAns_;
+        }
+      }
+      /**
+       * <code>optional .ECS.MonitorAns monitor_ans = 13;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder> 
+          getMonitorAnsFieldBuilder() {
+        if (monitorAnsBuilder_ == null) {
+          monitorAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder>(
+                  monitorAns_,
+                  getParentForChildren(),
+                  isClean());
+          monitorAns_ = null;
+        }
+        return monitorAnsBuilder_;
+      }
+
+      // optional .ECS.MonitorNtf monitor_ntf = 14;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf monitorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder> monitorNtfBuilder_;
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      public boolean hasMonitorNtf() {
+        return ((bitField0_ & 0x00002000) == 0x00002000);
+      }
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf getMonitorNtf() {
+        if (monitorNtfBuilder_ == null) {
+          return monitorNtf_;
+        } else {
+          return monitorNtfBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      public Builder setMonitorNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf value) {
+        if (monitorNtfBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          monitorNtf_ = value;
+          onChanged();
+        } else {
+          monitorNtfBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00002000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      public Builder setMonitorNtf(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder builderForValue) {
+        if (monitorNtfBuilder_ == null) {
+          monitorNtf_ = builderForValue.build();
+          onChanged();
+        } else {
+          monitorNtfBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00002000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      public Builder mergeMonitorNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf value) {
+        if (monitorNtfBuilder_ == null) {
+          if (((bitField0_ & 0x00002000) == 0x00002000) &&
+              monitorNtf_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance()) {
+            monitorNtf_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.newBuilder(monitorNtf_).mergeFrom(value).buildPartial();
+          } else {
+            monitorNtf_ = value;
+          }
+          onChanged();
+        } else {
+          monitorNtfBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00002000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      public Builder clearMonitorNtf() {
+        if (monitorNtfBuilder_ == null) {
+          monitorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance();
+          onChanged();
+        } else {
+          monitorNtfBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00002000);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder getMonitorNtfBuilder() {
+        bitField0_ |= 0x00002000;
+        onChanged();
+        return getMonitorNtfFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder getMonitorNtfOrBuilder() {
+        if (monitorNtfBuilder_ != null) {
+          return monitorNtfBuilder_.getMessageOrBuilder();
+        } else {
+          return monitorNtf_;
+        }
+      }
+      /**
+       * <code>optional .ECS.MonitorNtf monitor_ntf = 14;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder> 
+          getMonitorNtfFieldBuilder() {
+        if (monitorNtfBuilder_ == null) {
+          monitorNtfBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder>(
+                  monitorNtf_,
+                  getParentForChildren(),
+                  isClean());
+          monitorNtf_ = null;
+        }
+        return monitorNtfBuilder_;
+      }
+
+      // optional .ECS.NfcReq nfc_req = 101;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq nfcReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder> nfcReqBuilder_;
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      public boolean hasNfcReq() {
+        return ((bitField0_ & 0x00004000) == 0x00004000);
+      }
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq getNfcReq() {
+        if (nfcReqBuilder_ == null) {
+          return nfcReq_;
+        } else {
+          return nfcReqBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      public Builder setNfcReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq value) {
+        if (nfcReqBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          nfcReq_ = value;
+          onChanged();
+        } else {
+          nfcReqBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00004000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      public Builder setNfcReq(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder builderForValue) {
+        if (nfcReqBuilder_ == null) {
+          nfcReq_ = builderForValue.build();
+          onChanged();
+        } else {
+          nfcReqBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00004000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      public Builder mergeNfcReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq value) {
+        if (nfcReqBuilder_ == null) {
+          if (((bitField0_ & 0x00004000) == 0x00004000) &&
+              nfcReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance()) {
+            nfcReq_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.newBuilder(nfcReq_).mergeFrom(value).buildPartial();
+          } else {
+            nfcReq_ = value;
+          }
+          onChanged();
+        } else {
+          nfcReqBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00004000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      public Builder clearNfcReq() {
+        if (nfcReqBuilder_ == null) {
+          nfcReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance();
+          onChanged();
+        } else {
+          nfcReqBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00004000);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder getNfcReqBuilder() {
+        bitField0_ |= 0x00004000;
+        onChanged();
+        return getNfcReqFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder getNfcReqOrBuilder() {
+        if (nfcReqBuilder_ != null) {
+          return nfcReqBuilder_.getMessageOrBuilder();
+        } else {
+          return nfcReq_;
+        }
+      }
+      /**
+       * <code>optional .ECS.NfcReq nfc_req = 101;</code>
+       *
+       * <pre>
+       * Extensions 101 to 150;
+       * </pre>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder> 
+          getNfcReqFieldBuilder() {
+        if (nfcReqBuilder_ == null) {
+          nfcReqBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder>(
+                  nfcReq_,
+                  getParentForChildren(),
+                  isClean());
+          nfcReq_ = null;
+        }
+        return nfcReqBuilder_;
+      }
+
+      // optional .ECS.NfcNtf nfc_ntf = 102;
+      private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf nfcNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder> nfcNtfBuilder_;
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      public boolean hasNfcNtf() {
+        return ((bitField0_ & 0x00008000) == 0x00008000);
+      }
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf getNfcNtf() {
+        if (nfcNtfBuilder_ == null) {
+          return nfcNtf_;
+        } else {
+          return nfcNtfBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      public Builder setNfcNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf value) {
+        if (nfcNtfBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          nfcNtf_ = value;
+          onChanged();
+        } else {
+          nfcNtfBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00008000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      public Builder setNfcNtf(
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder builderForValue) {
+        if (nfcNtfBuilder_ == null) {
+          nfcNtf_ = builderForValue.build();
+          onChanged();
+        } else {
+          nfcNtfBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00008000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      public Builder mergeNfcNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf value) {
+        if (nfcNtfBuilder_ == null) {
+          if (((bitField0_ & 0x00008000) == 0x00008000) &&
+              nfcNtf_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance()) {
+            nfcNtf_ =
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.newBuilder(nfcNtf_).mergeFrom(value).buildPartial();
+          } else {
+            nfcNtf_ = value;
+          }
+          onChanged();
+        } else {
+          nfcNtfBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00008000;
+        return this;
+      }
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      public Builder clearNfcNtf() {
+        if (nfcNtfBuilder_ == null) {
+          nfcNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance();
+          onChanged();
+        } else {
+          nfcNtfBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00008000);
+        return this;
+      }
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder getNfcNtfBuilder() {
+        bitField0_ |= 0x00008000;
+        onChanged();
+        return getNfcNtfFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder getNfcNtfOrBuilder() {
+        if (nfcNtfBuilder_ != null) {
+          return nfcNtfBuilder_.getMessageOrBuilder();
+        } else {
+          return nfcNtf_;
+        }
+      }
+      /**
+       * <code>optional .ECS.NfcNtf nfc_ntf = 102;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder> 
+          getNfcNtfFieldBuilder() {
+        if (nfcNtfBuilder_ == null) {
+          nfcNtfBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder>(
+                  nfcNtf_,
+                  getParentForChildren(),
+                  isClean());
+          nfcNtf_ = null;
+        }
+        return nfcNtfBuilder_;
+      }
+
+      // @@protoc_insertion_point(builder_scope:ECS.Master)
+    }
+
+    static {
+      defaultInstance = new Master(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:ECS.Master)
+  }
+
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_CheckVersionReq_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_CheckVersionReq_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_CheckVersionAns_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_CheckVersionAns_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_KeepAliveReq_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_KeepAliveReq_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_KeepAliveAns_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_KeepAliveAns_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_InjectorReq_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_InjectorReq_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_InjectorAns_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_InjectorAns_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_InjectorNtf_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_InjectorNtf_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_DeviceReq_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_DeviceReq_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_DeviceAns_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_DeviceAns_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_DeviceNtf_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_DeviceNtf_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_MonitorReq_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_MonitorReq_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_MonitorAns_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_MonitorAns_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_MonitorNtf_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_MonitorNtf_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_NfcReq_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_NfcReq_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_NfcNtf_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_NfcNtf_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_ECS_Master_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_ECS_Master_fieldAccessorTable;
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n\tecs.proto\022\003ECS\032\recs_ids.proto\"&\n\017Check" +
+      "VersionReq\022\023\n\013version_str\030\001 \002(\t\"7\n\017Check" +
+      "VersionAns\022\017\n\007errcode\030\001 \002(\005\022\023\n\013version_s" +
+      "tr\030\002 \002(\t\" \n\014KeepAliveReq\022\020\n\010time_str\030\001 \001" +
+      "(\t\" \n\014KeepAliveAns\022\020\n\010time_str\030\001 \001(\t\"\\\n\013" +
+      "InjectorReq\022\020\n\010category\030\001 \002(\t\022\016\n\006length\030" +
+      "\002 \002(\005\022\r\n\005group\030\003 \002(\005\022\016\n\006action\030\004 \002(\005\022\014\n\004" +
+      "data\030\005 \001(\014\"@\n\013InjectorAns\022\017\n\007errcode\030\001 \002" +
+      "(\005\022\016\n\006errstr\030\002 \001(\t\022\020\n\010category\030\003 \002(\t\"\\\n\013" +
+      "InjectorNtf\022\020\n\010category\030\001 \002(\t\022\016\n\006length\030",
+      "\002 \002(\005\022\r\n\005group\030\003 \002(\005\022\016\n\006action\030\004 \002(\005\022\014\n\004" +
+      "data\030\005 \001(\014\"Z\n\tDeviceReq\022\020\n\010category\030\001 \002(" +
+      "\t\022\016\n\006length\030\002 \002(\005\022\r\n\005group\030\003 \002(\005\022\016\n\006acti" +
+      "on\030\004 \002(\005\022\014\n\004data\030\005 \001(\014\"{\n\tDeviceAns\022\017\n\007e" +
+      "rrcode\030\001 \002(\005\022\016\n\006errstr\030\002 \001(\t\022\020\n\010category" +
+      "\030\003 \002(\t\022\016\n\006length\030\004 \002(\005\022\r\n\005group\030\005 \002(\005\022\016\n" +
+      "\006action\030\006 \002(\005\022\014\n\004data\030\007 \001(\014\"Z\n\tDeviceNtf" +
+      "\022\020\n\010category\030\001 \002(\t\022\016\n\006length\030\002 \002(\005\022\r\n\005gr" +
+      "oup\030\003 \002(\005\022\016\n\006action\030\004 \002(\005\022\014\n\004data\030\005 \001(\014\"" +
+      "\035\n\nMonitorReq\022\017\n\007command\030\001 \002(\t\"L\n\nMonito",
+      "rAns\022\017\n\007errcode\030\001 \002(\005\022\016\n\006errmsg\030\002 \001(\t\022\017\n" +
+      "\007command\030\003 \002(\t\022\014\n\004data\030\004 \001(\014\"+\n\nMonitorN" +
+      "tf\022\017\n\007command\030\001 \002(\t\022\014\n\004data\030\002 \001(\014\"(\n\006Nfc" +
+      "Req\022\020\n\010category\030\001 \002(\t\022\014\n\004data\030\002 \001(\014\"(\n\006N" +
+      "fcNtf\022\020\n\010category\030\001 \002(\t\022\014\n\004data\030\002 \001(\014\"\356\004" +
+      "\n\006Master\022\036\n\004type\030\001 \002(\0162\020.ECS.Master_Type" +
+      "\022.\n\020checkversion_req\030\002 \001(\0132\024.ECS.CheckVe" +
+      "rsionReq\022.\n\020checkversion_ans\030\003 \001(\0132\024.ECS" +
+      ".CheckVersionAns\022(\n\rkeepalive_req\030\004 \001(\0132" +
+      "\021.ECS.KeepAliveReq\022(\n\rkeepalive_ans\030\005 \001(",
+      "\0132\021.ECS.KeepAliveAns\022&\n\014injector_req\030\006 \001" +
+      "(\0132\020.ECS.InjectorReq\022&\n\014injector_ans\030\007 \001" +
+      "(\0132\020.ECS.InjectorAns\022&\n\014injector_ntf\030\010 \001" +
+      "(\0132\020.ECS.InjectorNtf\022\"\n\ndevice_req\030\t \001(\013" +
+      "2\016.ECS.DeviceReq\022\"\n\ndevice_ans\030\n \001(\0132\016.E" +
+      "CS.DeviceAns\022\"\n\ndevice_ntf\030\013 \001(\0132\016.ECS.D" +
+      "eviceNtf\022$\n\013monitor_req\030\014 \001(\0132\017.ECS.Moni" +
+      "torReq\022$\n\013monitor_ans\030\r \001(\0132\017.ECS.Monito" +
+      "rAns\022$\n\013monitor_ntf\030\016 \001(\0132\017.ECS.MonitorN" +
+      "tf\022\034\n\007nfc_req\030e \001(\0132\013.ECS.NfcReq\022\034\n\007nfc_",
+      "ntf\030f \001(\0132\013.ECS.NfcNtfB0\n.org.tizen.dyna" +
+      "micanalyzer.ui.info.snapshot.ecs"
+    };
+    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+      new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+        public com.google.protobuf.ExtensionRegistry assignDescriptors(
+            com.google.protobuf.Descriptors.FileDescriptor root) {
+          descriptor = root;
+          internal_static_ECS_CheckVersionReq_descriptor =
+            getDescriptor().getMessageTypes().get(0);
+          internal_static_ECS_CheckVersionReq_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_CheckVersionReq_descriptor,
+              new java.lang.String[] { "VersionStr", });
+          internal_static_ECS_CheckVersionAns_descriptor =
+            getDescriptor().getMessageTypes().get(1);
+          internal_static_ECS_CheckVersionAns_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_CheckVersionAns_descriptor,
+              new java.lang.String[] { "Errcode", "VersionStr", });
+          internal_static_ECS_KeepAliveReq_descriptor =
+            getDescriptor().getMessageTypes().get(2);
+          internal_static_ECS_KeepAliveReq_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_KeepAliveReq_descriptor,
+              new java.lang.String[] { "TimeStr", });
+          internal_static_ECS_KeepAliveAns_descriptor =
+            getDescriptor().getMessageTypes().get(3);
+          internal_static_ECS_KeepAliveAns_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_KeepAliveAns_descriptor,
+              new java.lang.String[] { "TimeStr", });
+          internal_static_ECS_InjectorReq_descriptor =
+            getDescriptor().getMessageTypes().get(4);
+          internal_static_ECS_InjectorReq_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_InjectorReq_descriptor,
+              new java.lang.String[] { "Category", "Length", "Group", "Action", "Data", });
+          internal_static_ECS_InjectorAns_descriptor =
+            getDescriptor().getMessageTypes().get(5);
+          internal_static_ECS_InjectorAns_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_InjectorAns_descriptor,
+              new java.lang.String[] { "Errcode", "Errstr", "Category", });
+          internal_static_ECS_InjectorNtf_descriptor =
+            getDescriptor().getMessageTypes().get(6);
+          internal_static_ECS_InjectorNtf_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_InjectorNtf_descriptor,
+              new java.lang.String[] { "Category", "Length", "Group", "Action", "Data", });
+          internal_static_ECS_DeviceReq_descriptor =
+            getDescriptor().getMessageTypes().get(7);
+          internal_static_ECS_DeviceReq_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_DeviceReq_descriptor,
+              new java.lang.String[] { "Category", "Length", "Group", "Action", "Data", });
+          internal_static_ECS_DeviceAns_descriptor =
+            getDescriptor().getMessageTypes().get(8);
+          internal_static_ECS_DeviceAns_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_DeviceAns_descriptor,
+              new java.lang.String[] { "Errcode", "Errstr", "Category", "Length", "Group", "Action", "Data", });
+          internal_static_ECS_DeviceNtf_descriptor =
+            getDescriptor().getMessageTypes().get(9);
+          internal_static_ECS_DeviceNtf_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_DeviceNtf_descriptor,
+              new java.lang.String[] { "Category", "Length", "Group", "Action", "Data", });
+          internal_static_ECS_MonitorReq_descriptor =
+            getDescriptor().getMessageTypes().get(10);
+          internal_static_ECS_MonitorReq_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_MonitorReq_descriptor,
+              new java.lang.String[] { "Command", });
+          internal_static_ECS_MonitorAns_descriptor =
+            getDescriptor().getMessageTypes().get(11);
+          internal_static_ECS_MonitorAns_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_MonitorAns_descriptor,
+              new java.lang.String[] { "Errcode", "Errmsg", "Command", "Data", });
+          internal_static_ECS_MonitorNtf_descriptor =
+            getDescriptor().getMessageTypes().get(12);
+          internal_static_ECS_MonitorNtf_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_MonitorNtf_descriptor,
+              new java.lang.String[] { "Command", "Data", });
+          internal_static_ECS_NfcReq_descriptor =
+            getDescriptor().getMessageTypes().get(13);
+          internal_static_ECS_NfcReq_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_NfcReq_descriptor,
+              new java.lang.String[] { "Category", "Data", });
+          internal_static_ECS_NfcNtf_descriptor =
+            getDescriptor().getMessageTypes().get(14);
+          internal_static_ECS_NfcNtf_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_NfcNtf_descriptor,
+              new java.lang.String[] { "Category", "Data", });
+          internal_static_ECS_Master_descriptor =
+            getDescriptor().getMessageTypes().get(15);
+          internal_static_ECS_Master_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_ECS_Master_descriptor,
+              new java.lang.String[] { "Type", "CheckversionReq", "CheckversionAns", "KeepaliveReq", "KeepaliveAns", "InjectorReq", "InjectorAns", "InjectorNtf", "DeviceReq", "DeviceAns", "DeviceNtf", "MonitorReq", "MonitorAns", "MonitorNtf", "NfcReq", "NfcNtf", });
+          return null;
+        }
+      };
+    com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+          org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.getDescriptor(),
+        }, assigner);
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/EcsIds.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/EcsIds.java
new file mode 100644 (file)
index 0000000..5dfd1c1
--- /dev/null
@@ -0,0 +1,244 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ecs_ids.proto
+
+package org.tizen.dynamicanalyzer.ui.info.snapshot.ecs;
+
+public final class EcsIds {
+  private EcsIds() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+  }
+  /**
+   * Protobuf enum {@code ECS.Master_Type}
+   */
+  public enum Master_Type
+      implements com.google.protobuf.ProtocolMessageEnum {
+    /**
+     * <code>CHECKVERSION_REQ = 2;</code>
+     */
+    CHECKVERSION_REQ(0, 2),
+    /**
+     * <code>CHECKVERSION_ANS = 3;</code>
+     */
+    CHECKVERSION_ANS(1, 3),
+    /**
+     * <code>KEEPALIVE_REQ = 4;</code>
+     */
+    KEEPALIVE_REQ(2, 4),
+    /**
+     * <code>KEEPALIVE_ANS = 5;</code>
+     */
+    KEEPALIVE_ANS(3, 5),
+    /**
+     * <code>INJECTOR_REQ = 6;</code>
+     */
+    INJECTOR_REQ(4, 6),
+    /**
+     * <code>INJECTOR_ANS = 7;</code>
+     */
+    INJECTOR_ANS(5, 7),
+    /**
+     * <code>INJECTOR_NTF = 8;</code>
+     */
+    INJECTOR_NTF(6, 8),
+    /**
+     * <code>DEVICE_REQ = 9;</code>
+     */
+    DEVICE_REQ(7, 9),
+    /**
+     * <code>DEVICE_ANS = 10;</code>
+     */
+    DEVICE_ANS(8, 10),
+    /**
+     * <code>DEVICE_NTF = 11;</code>
+     */
+    DEVICE_NTF(9, 11),
+    /**
+     * <code>MONITOR_REQ = 12;</code>
+     */
+    MONITOR_REQ(10, 12),
+    /**
+     * <code>MONITOR_ANS = 13;</code>
+     */
+    MONITOR_ANS(11, 13),
+    /**
+     * <code>MONITOR_NTF = 14;</code>
+     */
+    MONITOR_NTF(12, 14),
+    /**
+     * <code>NFC_REQ = 101;</code>
+     */
+    NFC_REQ(13, 101),
+    /**
+     * <code>NFC_NTF = 102;</code>
+     */
+    NFC_NTF(14, 102),
+    ;
+
+    /**
+     * <code>CHECKVERSION_REQ = 2;</code>
+     */
+    public static final int CHECKVERSION_REQ_VALUE = 2;
+    /**
+     * <code>CHECKVERSION_ANS = 3;</code>
+     */
+    public static final int CHECKVERSION_ANS_VALUE = 3;
+    /**
+     * <code>KEEPALIVE_REQ = 4;</code>
+     */
+    public static final int KEEPALIVE_REQ_VALUE = 4;
+    /**
+     * <code>KEEPALIVE_ANS = 5;</code>
+     */
+    public static final int KEEPALIVE_ANS_VALUE = 5;
+    /**
+     * <code>INJECTOR_REQ = 6;</code>
+     */
+    public static final int INJECTOR_REQ_VALUE = 6;
+    /**
+     * <code>INJECTOR_ANS = 7;</code>
+     */
+    public static final int INJECTOR_ANS_VALUE = 7;
+    /**
+     * <code>INJECTOR_NTF = 8;</code>
+     */
+    public static final int INJECTOR_NTF_VALUE = 8;
+    /**
+     * <code>DEVICE_REQ = 9;</code>
+     */
+    public static final int DEVICE_REQ_VALUE = 9;
+    /**
+     * <code>DEVICE_ANS = 10;</code>
+     */
+    public static final int DEVICE_ANS_VALUE = 10;
+    /**
+     * <code>DEVICE_NTF = 11;</code>
+     */
+    public static final int DEVICE_NTF_VALUE = 11;
+    /**
+     * <code>MONITOR_REQ = 12;</code>
+     */
+    public static final int MONITOR_REQ_VALUE = 12;
+    /**
+     * <code>MONITOR_ANS = 13;</code>
+     */
+    public static final int MONITOR_ANS_VALUE = 13;
+    /**
+     * <code>MONITOR_NTF = 14;</code>
+     */
+    public static final int MONITOR_NTF_VALUE = 14;
+    /**
+     * <code>NFC_REQ = 101;</code>
+     */
+    public static final int NFC_REQ_VALUE = 101;
+    /**
+     * <code>NFC_NTF = 102;</code>
+     */
+    public static final int NFC_NTF_VALUE = 102;
+
+
+    public final int getNumber() { return value; }
+
+    public static Master_Type valueOf(int value) {
+      switch (value) {
+        case 2: return CHECKVERSION_REQ;
+        case 3: return CHECKVERSION_ANS;
+        case 4: return KEEPALIVE_REQ;
+        case 5: return KEEPALIVE_ANS;
+        case 6: return INJECTOR_REQ;
+        case 7: return INJECTOR_ANS;
+        case 8: return INJECTOR_NTF;
+        case 9: return DEVICE_REQ;
+        case 10: return DEVICE_ANS;
+        case 11: return DEVICE_NTF;
+        case 12: return MONITOR_REQ;
+        case 13: return MONITOR_ANS;
+        case 14: return MONITOR_NTF;
+        case 101: return NFC_REQ;
+        case 102: return NFC_NTF;
+        default: return null;
+      }
+    }
+
+    public static com.google.protobuf.Internal.EnumLiteMap<Master_Type>
+        internalGetValueMap() {
+      return internalValueMap;
+    }
+    private static com.google.protobuf.Internal.EnumLiteMap<Master_Type>
+        internalValueMap =
+          new com.google.protobuf.Internal.EnumLiteMap<Master_Type>() {
+            public Master_Type findValueByNumber(int number) {
+              return Master_Type.valueOf(number);
+            }
+          };
+
+    public final com.google.protobuf.Descriptors.EnumValueDescriptor
+        getValueDescriptor() {
+      return getDescriptor().getValues().get(index);
+    }
+    public final com.google.protobuf.Descriptors.EnumDescriptor
+        getDescriptorForType() {
+      return getDescriptor();
+    }
+    public static final com.google.protobuf.Descriptors.EnumDescriptor
+        getDescriptor() {
+      return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.getDescriptor().getEnumTypes().get(0);
+    }
+
+    private static final Master_Type[] VALUES = values();
+
+    public static Master_Type valueOf(
+        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
+      if (desc.getType() != getDescriptor()) {
+        throw new java.lang.IllegalArgumentException(
+          "EnumValueDescriptor is not for this type.");
+      }
+      return VALUES[desc.getIndex()];
+    }
+
+    private final int index;
+    private final int value;
+
+    private Master_Type(int index, int value) {
+      this.index = index;
+      this.value = value;
+    }
+
+    // @@protoc_insertion_point(enum_scope:ECS.Master_Type)
+  }
+
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n\recs_ids.proto\022\003ECS*\222\002\n\013Master_Type\022\024\n\020" +
+      "CHECKVERSION_REQ\020\002\022\024\n\020CHECKVERSION_ANS\020\003" +
+      "\022\021\n\rKEEPALIVE_REQ\020\004\022\021\n\rKEEPALIVE_ANS\020\005\022\020" +
+      "\n\014INJECTOR_REQ\020\006\022\020\n\014INJECTOR_ANS\020\007\022\020\n\014IN" +
+      "JECTOR_NTF\020\010\022\016\n\nDEVICE_REQ\020\t\022\016\n\nDEVICE_A" +
+      "NS\020\n\022\016\n\nDEVICE_NTF\020\013\022\017\n\013MONITOR_REQ\020\014\022\017\n" +
+      "\013MONITOR_ANS\020\r\022\017\n\013MONITOR_NTF\020\016\022\013\n\007NFC_R" +
+      "EQ\020e\022\013\n\007NFC_NTF\020fB0\n.org.tizen.dynamican" +
+      "alyzer.ui.info.snapshot.ecs"
+    };
+    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+      new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+        public com.google.protobuf.ExtensionRegistry assignDescriptors(
+            com.google.protobuf.Descriptors.FileDescriptor root) {
+          descriptor = root;
+          return null;
+        }
+      };
+    com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+        }, assigner);
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
index 9985a15..6cab103 100644 (file)
@@ -34,6 +34,7 @@ import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.widgets.Display;
 import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
 import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
 import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
 import org.tizen.dynamicanalyzer.resources.ImageResources;
 import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
@@ -41,6 +42,7 @@ import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
 import org.tizen.dynamicanalyzer.swap.logparser.Logs;
 import org.tizen.dynamicanalyzer.swap.model.data.LogData;
 import org.tizen.dynamicanalyzer.swap.model.data.ScreenShotData;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.SocketClient;
 import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
@@ -112,7 +114,16 @@ public class ScreenshotChart extends TimelineChart {
                                        + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
                                        + File.separator
                                        + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME;
-                       String imagePathLog = logData.getImageFilePath();
+                       String imagePathLog;
+                       
+                       if(DACommunicator.isTargetEmulator() 
+                                       && SocketClient.getInstance().isConnected()) {
+                               imagePathLog = DACommunicator.getSelectedDevice()
+                                               .emulatorSnapshot.getFilePath(); 
+                       } else {
+                               imagePathLog = logData.getImageFilePath();
+                       }
                        String[] splitedImagePathLog = imagePathLog.split("/"); //$NON-NLS-1$
                        String fileName = splitedImagePathLog[splitedImagePathLog.length - 1];
                        imagePath += File.separator + fileName;
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/ImageUtilSWT.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/ImageUtilSWT.java
new file mode 100644 (file)
index 0000000..e56fc6b
--- /dev/null
@@ -0,0 +1,177 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * Woojin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Munkyu Im <munkyu.im@samsung.com>
+ * GiWoong Kim <giwoong.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
+ * HyunJun Son
+ *
+ * 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.utils;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.SWTError;
+import org.eclipse.swt.SWTException;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.ImageData;
+import org.eclipse.swt.graphics.ImageLoader;
+import org.eclipse.swt.widgets.Display;
+
+public class ImageUtilSWT {
+       
+       /*
+        * reference web page : http://www.java2s.com/Code/Java/SWT-JFace-Eclipse/Rotateandflipanimage.htm
+        */
+       private static ImageData rotateImageData( ImageData srcData, int direction ) {
+               int bytesPerPixel = srcData.bytesPerLine / srcData.width;
+               int destBytesPerLine = ( direction == SWT.DOWN ) ? srcData.width * bytesPerPixel : srcData.height
+                               * bytesPerPixel;
+               byte[] newData = new byte[srcData.data.length];
+               int width = 0, height = 0;
+               for ( int srcY = 0; srcY < srcData.height; srcY++ ) {
+                       for ( int srcX = 0; srcX < srcData.width; srcX++ ) {
+                               int destX = 0, destY = 0, destIndex = 0, srcIndex = 0;
+                               switch ( direction ) {
+                               case SWT.LEFT: // left 90 degrees
+                                       destX = srcY;
+                                       destY = srcData.width - srcX - 1;
+                                       width = srcData.height;
+                                       height = srcData.width;
+                                       break;
+                               case SWT.RIGHT: // right 90 degrees
+                                       destX = srcData.height - srcY - 1;
+                                       destY = srcX;
+                                       width = srcData.height;
+                                       height = srcData.width;
+                                       break;
+                               case SWT.DOWN: // 180 degrees
+                                       destX = srcData.width - srcX - 1;
+                                       destY = srcData.height - srcY - 1;
+                                       width = srcData.width;
+                                       height = srcData.height;
+                                       break;
+                               }
+                               destIndex = ( destY * destBytesPerLine ) + ( destX * bytesPerPixel );
+                               srcIndex = ( srcY * srcData.bytesPerLine ) + ( srcX * bytesPerPixel );
+                               System.arraycopy( srcData.data, srcIndex, newData, destIndex, bytesPerPixel );
+                       }
+               }
+               // destBytesPerLine is used as scanlinePad to ensure that no padding is
+               // required
+               return new ImageData( width, height, srcData.depth, srcData.palette, destBytesPerLine, newData );
+       }
+       
+       private static void saveFile(Image image, String filePath) {
+               if ( null == filePath ) {
+                       return;
+               }
+
+               FileOutputStream fos = null;
+
+               try {
+                       ImageLoader loader = new ImageLoader();
+                       loader.data = new ImageData[] { image.getImageData() };
+
+                       fos = new FileOutputStream( filePath, false );
+                       loader.save( fos, SWT.IMAGE_PNG );
+               } catch ( FileNotFoundException ex ) {
+                       ex.printStackTrace();
+               } catch ( Exception ex ) {
+                       ex.printStackTrace();
+               } finally {
+                       try {
+                               if (null != fos) {
+                                       fos.close();
+                               }
+                       } catch (IOException e) {
+                               e.printStackTrace();
+                       }
+               }
+       }
+
+       private static Image createResizedImage(Image imageOrigin,
+                       int width, int height) {
+               if (imageOrigin == null) {
+                       return null;
+               }
+
+               ImageData imageDataSrc = imageOrigin.getImageData();
+               ImageData imageDataDst = (ImageData) imageDataSrc.clone();
+
+               imageDataDst = imageDataDst.scaledTo(width, height);
+
+               return new Image(Display.getDefault(), imageDataDst);
+       }
+
+       public static void transform(String originFilePath, String newFilePath,
+                       int width, int height, int angle) {
+               Image img = null;
+               ImageData newImageData = null;
+
+               try {
+                       img = new Image(Display.getDefault(), originFilePath);
+                       Image scaledImage = createResizedImage(img, width, height);
+
+                       if (angle == 0) {
+                               newImageData = scaledImage.getImageData();
+                       } else if (angle == 90) {
+                               newImageData = rotateImageData(scaledImage.getImageData(), SWT.RIGHT);
+                       } else if (angle == 270) {
+                               newImageData = rotateImageData(scaledImage.getImageData(), SWT.LEFT);
+                       } else if (angle == 180) {
+                               newImageData = rotateImageData(scaledImage.getImageData(), SWT.DOWN);
+                       }
+                       Image newImage = new Image(Display.getDefault(), newImageData);
+                       saveFile(newImage, newFilePath);
+               } catch (IllegalArgumentException e) {
+                       e.printStackTrace();
+               } catch (SWTError err) {
+                       err.printStackTrace();
+               } catch (SWTException e) {
+                       e.printStackTrace();
+               }
+       }
+               
+       public static void resize(String originFilePath, String newFilePath,
+                       int width, int height) {
+               Image img = null;
+
+               try {
+                       img = new Image(Display.getDefault(), originFilePath);
+                       Image scaledImage = createResizedImage(img, width, height);
+                       
+                       saveFile(scaledImage, newFilePath);
+               } catch (IllegalArgumentException e) {
+                       e.printStackTrace();
+               } catch (SWTError err) {
+                       err.printStackTrace();
+               } catch (SWTException e) {
+                       e.printStackTrace();
+               }
+       }
+}
diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/JsonUtil.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/JsonUtil.java
new file mode 100644 (file)
index 0000000..cb925e1
--- /dev/null
@@ -0,0 +1,141 @@
+/*
+ *  Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: 
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ * Jinhyung Choi <jinhyung2.choi@samsung.com>
+ * MunKyu Im <munkyu.im@samsung.com>
+ * Daiyoung Kim <daiyoung777.kim@samsung.com>
+ * YeongKyoon Lee <yeongkyoon.lee@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.utils;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+import org.tizen.dynamicanalyzer.ui.info.snapshot.SocketConstants;
+
+public class JsonUtil {
+       public static final String CMD_SCREENDUMP = "screendump";
+       public static final String CMD_EXECUTE = "execute";
+       public static final String CMD_ARGS = "arguments";
+       public static final String ARG_FILENAME = "filename";
+
+       private static JSONParser parser = new JSONParser();
+
+       public static JSONObject decodeObject(String message) {
+               JSONObject obj = null;
+               if (null == message) {
+                       System.out.println("decodeObject - message string is null.");
+                       return obj;
+               }
+               try {
+                       obj = (JSONObject) parser.parse(message);
+               } catch (ParseException e) {
+                       e.printStackTrace();
+                       System.out.println("[info] position: " + e.getPosition());
+                       System.out.println("[info] " + e.toString());
+               }
+               return obj;
+       }
+
+       public static JSONArray decodeArray(String message) {
+               JSONArray obj = null;
+               if (null == message) {
+                       System.out.println("decodeArray - message string is null.");
+                       return obj;
+               }
+               try {
+                       obj = (JSONArray) parser.parse(message);
+               } catch (ParseException e) {
+                       System.out.println("[info] position: " + e.getPosition());
+                       System.out.println("[info] " + e.toString());
+               }
+               return obj;
+       }
+
+       public static String decodeString(String message) {
+               if (null == message) {
+                       System.out.println("decodeArray - message string is null.");
+                       return null;
+               }
+               JSONObject obj = decodeObject(message);
+               if (null == obj) {
+                       return null;
+               }
+               return obj.toJSONString();
+       }
+
+       @SuppressWarnings("unchecked")
+       public static String encodeString(String key, String value) {
+               if (null == value) {
+                       return null;
+               }
+               JSONObject obj = new JSONObject();
+
+               obj.put(key, value);
+
+               return obj.toJSONString().trim();
+       }
+
+       @SuppressWarnings("unchecked")
+       public static String encodeString(String key1, String value1, String key2,
+                       String value2) {
+               JSONObject obj = new JSONObject();
+               obj.put(key1, value1);
+               obj.put(key2, value2);
+
+               return obj.toJSONString().trim();
+       }
+
+       @SuppressWarnings("unchecked")
+       public static String encodeString(String key1, String value1, String key2,
+                       JSONObject objs) {
+               JSONObject obj = new JSONObject();
+               obj.put(key1, value1);
+               obj.put(key2, objs);
+
+               return obj.toJSONString().trim();
+       }
+
+       @SuppressWarnings("unchecked")
+       public static String encodeString(String key1, String value1, String key2,
+                       JSONObject objs, String type) {
+               JSONObject obj = new JSONObject();
+               obj.put(key1, value1);
+               obj.put(key2, objs);
+               obj.put(SocketConstants.MESSAGE_TYPE, type);
+
+               return obj.toJSONString().trim();
+       }
+       
+       @SuppressWarnings("unchecked")
+       public static JSONObject encodeObject(String key, String value) {
+               JSONObject obj = new JSONObject();
+
+               obj.put(key, value);
+
+               return obj;
+       }
+}