[Feature-Timeline]: Apply refactoring Database to Timeline chart (ing)

[Description] : DeviceChart, DiskIOChart, NetworkIOChart, ProcessMemoryChart, SystemMemoryChart

Change-Id: I8969b9e3396a1aebf11195069fc8e3ac6ee2b4ff
Signed-off-by: jungwook.ryu <jungwook.ryu@samsung.com>

diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/chartBoard/DAChartBoard.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/chartBoard/DAChartBoard.java
index c61decb..2e53b21 100644 (file)
--- a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/chartBoard/DAChartBoard.java
+++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/chartBoard/DAChartBoard.java
@@ -113,6 +113,9 @@ public class DAChartBoard extends Composite {
        public final static int BOARD_STYLE_FRAME = 1;
        public final static int BOARD_STYLE_KERNEL = 2;
 
+       
+       private IDAChartSeriesMaker chartSeriesMaker;
+       
        public DAChartBoard(Composite parent, String title) {
                this(parent, title, BOARD_STYLE_TIME);
        }
@@ -392,8 +395,16 @@ public class DAChartBoard extends Composite {
                        callBackSizeChanged();
                }
        };
-
+       
+       public void setChartSeriesMaker(IDAChartSeriesMaker chartSeriesMaker) {
+               this.chartSeriesMaker = chartSeriesMaker;
+       }
+       
        private void setChartAxis() {
+               if (chartSeriesMaker != null) {
+                   chartSeriesMaker.makeChartSeries((long)(getVisibleStartTime() * 1000000.0), 
+                           (long)(getVisibleEndTime() * 1000000.0));
+               }
                itemList.setChartAxis(getVisibleStartTime(), getVisibleEndTime());
        }
 
@@ -497,6 +508,11 @@ public class DAChartBoard extends Composite {
                if (lifecycleBar != null) {
                        lifecycleBar.setTotalEndTime(endTime);
                }
+               
+               if (chartSeriesMaker != null) {
+                       chartSeriesMaker.makeChartSeries((long)(getVisibleStartTime() * 1000000.0), 
+                           (long)(getVisibleEndTime() * 1000000.0));
+               }
        }
 
        private void markerContentsClear() {

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/DeviceChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/DeviceChart.java
index 2323a2f..883b66a 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/DeviceChart.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/DeviceChart.java
@@ -10,7 +10,9 @@ 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.SystemData;
+import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable;
 import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
+import org.tizen.dynamicanalyzer.utils.Formatter;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
@@ -99,28 +101,24 @@ public class DeviceChart extends TimelineChart {
                
                return item;
        }
-
+       
        @Override
-       public void parseLogPackage(LogPackage logPack) {
-               Logs logs = logPack.getLogs(probeType);
-               if (logs == null) {
-                       return;
-               }
-
-               List<LogData> logList = logs.getRawLogs();
-               for (LogData logData : logList) {
-                       parseLog((SystemData) logData);
-               }
-       }
-
-       private void parseLog(SystemData logData) {
-               try {
-                       double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
-                       int wifi = logData.getWifi();
-                       int bluetooth = logData.getBtStatus();
-                       int gps = logData.getGpsStatus();
-                       int dnet = logData.getDnet();
-                       int camera = logData.getCamera();
+       public void inputChartSeries(List<List<Object>> data) {
+               wifiSeries.clear();
+               bluetoothSeries.clear();
+               gpsSeries.clear();
+               dnetSeries.clear();
+               cameraSeries.clear();
+               
+               for (int i = 0; i < data.size(); i++) {
+                       List<Object> row = data.get(i);
+                       double time = (Long)row.get(SystemDataDBTable.COLUMN.TIME.ordinal())
+                               / TimelineConstants.MEGA_DOUBLE;
+                       int wifi = (Integer)row.get(SystemDataDBTable.COLUMN.DEVICE_STATUS_WIFI.ordinal());
+                       int bluetooth = (Integer)row.get(SystemDataDBTable.COLUMN.DEVICE_STATUS_BLUETOOTH.ordinal());
+                       int gps = (Integer)row.get(SystemDataDBTable.COLUMN.DEVICE_STATUS_GPS.ordinal());
+                       int dnet = (Integer)row.get(SystemDataDBTable.COLUMN.DEVICE_STATUS_DNET.ordinal());
+                       int camera = (Integer)row.get(SystemDataDBTable.COLUMN.DEVICE_STATUS_CAMERA.ordinal());
                        
                        wifiSeries.addSeriesItem(new DAChartSeriesItem(time, wifi,
                                        WIFI_STATES[wifi]));
@@ -132,8 +130,10 @@ public class DeviceChart extends TimelineChart {
                                        DNET_STATES[dnet]));
                        cameraSeries.addSeriesItem(new DAChartSeriesItem(time, camera,
                                        CAMERA_STATES[camera]));
-               } catch (NumberFormatException ne) {
-                       ne.printStackTrace();
-               }
+               }
+       }
+       
+       @Override
+       public void parseLogPackage(LogPackage logPack) {
        }
 }

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/DiskIOChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/DiskIOChart.java
index 4e926bf..ae2873c 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/DiskIOChart.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/DiskIOChart.java
@@ -36,6 +36,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.SystemData;
+import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable;
 import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
 import org.tizen.dynamicanalyzer.utils.Formatter;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
@@ -93,32 +94,37 @@ public class DiskIOChart extends TimelineChart {
 
                return item;
        }
-
+       
        @Override
-       public void parseLogPackage(LogPackage logPack) {
-               Logs logs = logPack.getLogs(probeType);
-               if (logs == null) {
-                       return;
-               }
-
-               List<LogData> logList = logs.getRawLogs();
-
-               for (LogData logData : logList) {
-                       parseLog((SystemData) logData);
-               }
-       }
-
-       private void parseLog(SystemData log) {
-               try {
-                       double time = log.getTime() / TimelineConstants.MEGA_DOUBLE;
-                       int readSize = log.getDiskReadSize();
-                       int writeSize = log.getDiskWriteSize();
-                       
+       public void inputChartSeries(List<List<Object>> data) {
+               readSeries.clear();
+               writeSeries.clear();
+               
+               for (int i = 0; i < data.size(); i++) {
+                       List<Object> row = data.get(i);
+                       double time = (Long)row.get(SystemDataDBTable.COLUMN.TIME.ordinal())
+                               / TimelineConstants.MEGA_DOUBLE;
+                       int readSize = (Integer)row.get(SystemDataDBTable.COLUMN.DISK_IO_READ_SIZE.ordinal());
+                       int writeSize = (Integer)row.get(SystemDataDBTable.COLUMN.DISK_IO_WRITE_SIZE.ordinal());
+               
                        readSeries.addSeriesItem(new DAChartSeriesItem(time, readSize,
-                                       Formatter.toByteFormat(readSize)));
+                               Formatter.toByteFormat(readSize)));
                        writeSeries.addSeriesItem(new DAChartSeriesItem(time, writeSize,
-                                       Formatter.toByteFormat(writeSize)));
-               } catch (NumberFormatException ne) {
-               }
+                               Formatter.toByteFormat(writeSize)));
+               }
+       }
+
+       @Override
+       public void parseLogPackage(LogPackage logPack) {
+//             Logs logs = logPack.getLogs(probeType);
+//             if (logs == null) {
+//                     return;
+//             }
+//
+//             List<LogData> logList = logs.getRawLogs();
+//
+//             for (LogData logData : logList) {
+//                     parseLog((SystemData) logData);
+//             }
        }
 }

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/HeapChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/HeapChart.java
index 6f82921..3674563 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/HeapChart.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/HeapChart.java
@@ -38,6 +38,7 @@ import org.tizen.dynamicanalyzer.swap.logparser.Logs;
 import org.tizen.dynamicanalyzer.swap.model.data.LogData;
 import org.tizen.dynamicanalyzer.swap.model.data.MemoryData;
 import org.tizen.dynamicanalyzer.swap.model.data.SystemData;
+import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable;
 import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
 import org.tizen.dynamicanalyzer.utils.Formatter;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
@@ -99,6 +100,27 @@ public class HeapChart extends TimelineChart {
        }
 
        @Override
+       public void inputChartSeries(List<List<Object>> data) {
+//             totalAllocationSeries.clear();
+//             userAllocationSeries.clear();
+//             
+//             for (int i = 0; i < data.size(); i++) {
+//                     List<Object> row = data.get(i);
+//                     double time = (Long)row.get(SystemDataDBTable.COLUMN.TIME.ordinal())
+//                             / TimelineConstants.MEGA_DOUBLE;
+//                     double totalAlloc = (Long)row.get(SystemDataDBTable.COLUMN.HEAP_ALLOCATION_TOTAL.ordinal());
+//                     double userAlloc = (Long)row.get(SystemDataDBTable.COLUMN.HEAP_ALLOCATION_APP.ordinal());
+//             
+//                     totalAllocationSeries.addSeriesItem(new DAChartSeriesItem(
+//                             time, totalAlloc, Formatter.toByteFormat(totalAlloc)));
+//
+//                     userAllocationSeries.addSeriesItem(new DAChartSeriesItem(time,
+//                             userAlloc, Formatter.toByteFormat(allocByte)));
+//             }
+       }
+
+       
+       @Override
        public void parseLogPackage(LogPackage logPack) {
                Logs memoryLogs = logPack
                                .getLogs(DataChannelConstants.MSG_PROBE_MEMORY);

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/NetworkIOChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/NetworkIOChart.java
index ff9caac..0edcc16 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/NetworkIOChart.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/NetworkIOChart.java
@@ -33,9 +33,7 @@ import org.tizen.dynamicanalyzer.resources.ColorResources;
 import org.tizen.dynamicanalyzer.resources.ImageResources;
 import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
 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.SystemData;
+import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable;
 import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
 import org.tizen.dynamicanalyzer.utils.Formatter;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
@@ -91,32 +89,52 @@ public class NetworkIOChart extends TimelineChart {
 
                return item;
        }
+       
+       @Override
+       public void inputChartSeries(List<List<Object>> data) {
+               sendSeries.clear();
+               receiveSeries.clear();
+               
+               for (int i = 0; i < data.size(); i++) {
+                       List<Object> row = data.get(i);
+                       double time = (Long)row.get(SystemDataDBTable.COLUMN.TIME.ordinal())
+                               / TimelineConstants.MEGA_DOUBLE;
+                       int sendSize = (Integer)row.get(SystemDataDBTable.COLUMN.NETWORK_SIZE_SEND.ordinal());
+                       int receiveSize = (Integer)row.get(SystemDataDBTable.COLUMN.NETWORK_SIZE_RECEIVE.ordinal());
+               
+                       sendSeries.addSeriesItem(new DAChartSeriesItem(
+                               time, sendSize, Formatter.toByteFormat(sendSize)));
+
+                       receiveSeries.addSeriesItem(new DAChartSeriesItem(time,
+                               receiveSize, Formatter.toByteFormat(receiveSize)));
+               }
+       }
 
        @Override
        public void parseLogPackage(LogPackage logPack) {
-               Logs logs = logPack.getLogs(probeType);
-               if (logs == null) {
-                       return;
-               }
-
-               List<LogData> logList = logs.getRawLogs();
-
-               for (LogData logData : logList) {
-                       parseLog((SystemData) logData);
-               }
+//             Logs logs = logPack.getLogs(probeType);
+//             if (logs == null) {
+//                     return;
+//             }
+//
+//             List<LogData> logList = logs.getRawLogs();
+//
+//             for (LogData logData : logList) {
+//                     parseLog((SystemData) logData);
+//             }
        }
 
-       private void parseLog(SystemData log) {
-               try {
-                       double time = log.getTime() / TimelineConstants.MEGA_DOUBLE;
-                       int sendSize = log.getNetworkSendSize();
-                       int receiveSize = log.getNetworkReceiveSize();
-                       sendSeries.addSeriesItem(new DAChartSeriesItem(time, sendSize,
-                                       Formatter.toByteFormat(sendSize)));
-                       receiveSeries.addSeriesItem(new DAChartSeriesItem(time, receiveSize,
-                                       Formatter.toByteFormat(receiveSize)));
-
-               } catch (NumberFormatException ne) {
-               }
-       }
+//     private void parseLog(SystemData log) {
+//             try {
+//                     double time = log.getTime() / TimelineConstants.MEGA_DOUBLE;
+//                     int sendSize = log.getNetworkSendSize();
+//                     int receiveSize = log.getNetworkReceiveSize();
+//                     sendSeries.addSeriesItem(new DAChartSeriesItem(time, sendSize,
+//                                     Formatter.toByteFormat(sendSize)));
+//                     receiveSeries.addSeriesItem(new DAChartSeriesItem(time, receiveSize,
+//                                     Formatter.toByteFormat(receiveSize)));
+//
+//             } catch (NumberFormatException ne) {
+//             }
+//     }
 }

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ProcessMemoryChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ProcessMemoryChart.java
index 7c421cc..6d39e6d 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ProcessMemoryChart.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ProcessMemoryChart.java
@@ -33,9 +33,7 @@ import org.tizen.dynamicanalyzer.resources.ColorResources;
 import org.tizen.dynamicanalyzer.resources.ImageResources;
 import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
 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.SystemData;
+import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable;
 import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
 import org.tizen.dynamicanalyzer.utils.Formatter;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
@@ -58,7 +56,7 @@ public class ProcessMemoryChart extends TimelineChart {
 
                return instance;
        }
-
+       
        private ProcessMemoryChart() {
                chartType = TimelineConstants.CHART_TYPE_PROCESS_MEMORY;
                probeType = DataChannelConstants.MSG_DATA_SYSTEM;
@@ -94,53 +92,76 @@ public class ProcessMemoryChart extends TimelineChart {
 
                return item;
        }
-
+       
        @Override
-       public void parseLogPackage(LogPackage logPack) {
-               Logs logs = logPack.getLogs(probeType);
-               if(logs == null) {
-                       return;
-               }
-               
-               List<LogData> logList = logs.getRawLogs();
-
-               for (LogData logData : logList) {
-                       parseLog((SystemData)logData);
-               }
+       public void inputChartSeries(List<List<Object>> data) {
+               VSSMemorySeries.clear();
+               RSSMemorySeries.clear();
+               PSSMemorySeries.clear();
+               
+               for (int i = 0; i < data.size(); i++) {
+                       List<Object> row = data.get(i);
+                       double time = (Long)row.get(SystemDataDBTable.COLUMN.TIME.ordinal()) 
+                               / TimelineConstants.MEGA_DOUBLE;
+                       int vssMemory = (Integer)row.get(SystemDataDBTable.COLUMN.MEMORY_VIRTUAL.ordinal());
+                       int rssMemory = (Integer)row.get(SystemDataDBTable.COLUMN.MEMORY_RESIDENT.ordinal());
+                       int pssMemory = (Integer)row.get(SystemDataDBTable.COLUMN.MEMORY_PSS.ordinal());
+               
+                       VSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, vssMemory,
+                                       Formatter.toByteFormat(vssMemory)));
+                       RSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, rssMemory,
+                               Formatter.toByteFormat(rssMemory)));
+                       PSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, pssMemory,
+                               Formatter.toByteFormat(pssMemory)));
+               }
        }
-
-       private void parseLog(SystemData logData) {
-               /* VSS */
-               try {
-                       double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
-                       int value = logData.getVirtualMemory();
-
-                       VSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, value,
-                                       Formatter.toByteFormat(value)));
-               } catch (NumberFormatException ne) {
-                       ne.printStackTrace();
-               }
-
-               /* RSS */
-               try {
-                       double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
-                       int value = logData.getResidentMemory();
-
-                       RSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, value,
-                                       Formatter.toByteFormat(value)));
-               } catch (NumberFormatException ne) {
-                       ne.printStackTrace();
-               }
-
-               /* PSS */
-               try {
-                       double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
-                       int value = logData.getPssMemory();
-
-                       PSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, value,
-                                       Formatter.toByteFormat(value)));
-               } catch (NumberFormatException ne) {
-                       ne.printStackTrace();
-               }
+       
+       @Override
+       public void parseLogPackage(LogPackage logPack) {
+//             Logs logs = logPack.getLogs(probeType);
+//             if(logs == null) {
+//                     return;
+//             }
+//             
+//             List<LogData> logList = logs.getRawLogs();
+//
+//             for (LogData logData : logList) {
+//                     parseLog((SystemData)logData);
+//             }
        }
+       
+//     private void parseLog(SystemData logData) {
+//             /* VSS */
+//             try {
+//                     double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
+//                     int value = logData.getVirtualMemory();
+//
+//                     VSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, value,
+//                                     Formatter.toByteFormat(value)));
+//             } catch (NumberFormatException ne) {
+//                     ne.printStackTrace();
+//             }
+//
+//             /* RSS */
+//             try {
+//                     double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
+//                     int value = logData.getResidentMemory();
+//
+//                     RSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, value,
+//                                     Formatter.toByteFormat(value)));
+//             } catch (NumberFormatException ne) {
+//                     ne.printStackTrace();
+//             }
+//
+//             /* PSS */
+//             try {
+//                     double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
+//                     int value = logData.getPssMemory();
+//
+//                     PSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, value,
+//                                     Formatter.toByteFormat(value)));
+//             } catch (NumberFormatException ne) {
+//                     ne.printStackTrace();
+//             }
+//     }
 }

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/SystemMemoryChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/SystemMemoryChart.java
index 30b05bf..104571a 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/SystemMemoryChart.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/SystemMemoryChart.java
@@ -28,15 +28,12 @@ package org.tizen.dynamicanalyzer.ui.timeline.chart;
 
 import java.util.List;
 
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
 import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
 import org.tizen.dynamicanalyzer.resources.ColorResources;
 import org.tizen.dynamicanalyzer.resources.ImageResources;
 import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
 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.SystemData;
+import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable;
 import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
 import org.tizen.dynamicanalyzer.utils.Formatter;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
@@ -97,44 +94,67 @@ public class SystemMemoryChart extends TimelineChart {
        }
 
        @Override
+       public void inputChartSeries(List<List<Object>> data) {
+               processSeries.clear();
+               systemSeries.clear();
+               totalSeries.clear();
+       
+       for (int i = 0; i < data.size(); i++) {
+           List<Object> row = data.get(i);
+           double time = (Long)row.get(SystemDataDBTable.COLUMN.TIME.ordinal()) 
+                       / TimelineConstants.MEGA_DOUBLE;
+           int processUsageMemory = (Integer)row.get(SystemDataDBTable.COLUMN.MEMORY_RESIDENT.ordinal());
+           long systemUsageMemory = (Long)row.get(SystemDataDBTable.COLUMN.MEMORY_USAGE_SYSTEM.ordinal());
+           long totalMemory = (Long)row.get(SystemDataDBTable.COLUMN.MEMORY_TOTAL_SYSTEM.ordinal());
+           
+           processSeries.addSeriesItem(new DAChartSeriesItem(time, processUsageMemory,
+                                       Formatter.toByteFormat(processUsageMemory)));
+           systemSeries.addSeriesItem(new DAChartSeriesItem(time, systemUsageMemory,
+                                       Formatter.toByteFormat(systemUsageMemory)));
+           totalSeries.addSeriesItem(new DAChartSeriesItem(time, totalMemory,
+                                       Formatter.toByteFormat(totalMemory)));
+       }
+       }
+       
+       @Override
        public void parseLogPackage(LogPackage logPack) {
-               Logs logs = logPack.getLogs(probeType);
-               if(logs == null) {
-                       return;
-               }
-               
-               List<LogData> logList = logs.getRawLogs();
-
-               for (LogData logData : logList) {
-                       parseLog((SystemData)logData);
-               }
+//             Logs logs = logPack.getLogs(probeType);
+//             if(logs == null) {
+//                     return;
+//             }
+//             
+//             List<LogData> logList = logs.getRawLogs();
+//
+//             for (LogData logData : logList) {
+//                     parseLog((SystemData)logData);
+//             }
        }
 
-       private void parseLog(SystemData log) {
-               /* process */
-               try {
-                       double time = log.getTime() / TimelineConstants.MEGA_DOUBLE;
-                       int usage = log.getResidentMemory();
-                       processSeries.addSeriesItem(new DAChartSeriesItem(time, usage,
-                                       Formatter.toByteFormat(usage)));
-               } catch (NumberFormatException ne) {
-                       ne.printStackTrace();
-               }
-
-               /* system & total */
-               try {
-                       double time = log.getTime() / TimelineConstants.MEGA_DOUBLE;
-
-                       long usage = log.getSystemMemoryUsed();
-                       double total = (double) AnalyzerManager.getProject()
-                                       .getSystemMemorySize();
-
-                       systemSeries.addSeriesItem(new DAChartSeriesItem(time, usage,
-                                       Formatter.toByteFormat(usage)));
-                       totalSeries.addSeriesItem(new DAChartSeriesItem(time, total,
-                                       Formatter.toByteFormat(total)));
-               } catch (NumberFormatException ne) {
-                       ne.printStackTrace();
-               }
-       }
+//     private void parseLog(SystemData log) {
+//             /* process */
+//             try {
+//                     double time = log.getTime() / TimelineConstants.MEGA_DOUBLE;
+//                     int usage = log.getResidentMemory();
+//                     processSeries.addSeriesItem(new DAChartSeriesItem(time, usage,
+//                                     Formatter.toByteFormat(usage)));
+//             } catch (NumberFormatException ne) {
+//                     ne.printStackTrace();
+//             }
+//
+//             /* system & total */
+//             try {
+//                     double time = log.getTime() / TimelineConstants.MEGA_DOUBLE;
+//
+//                     long usage = log.getSystemMemoryUsed();
+//                     double total = (double) AnalyzerManager.getProject()
+//                                     .getSystemMemorySize();
+//
+//                     systemSeries.addSeriesItem(new DAChartSeriesItem(time, usage,
+//                                     Formatter.toByteFormat(usage)));
+//                     totalSeries.addSeriesItem(new DAChartSeriesItem(time, total,
+//                                     Formatter.toByteFormat(total)));
+//             } catch (NumberFormatException ne) {
+//                     ne.printStackTrace();
+//             }
+//     }
 }

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/TimelineChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/TimelineChart.java
index 7f80b5c..d6d0b2c 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/TimelineChart.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/TimelineChart.java
@@ -59,7 +59,9 @@ public abstract class TimelineChart {
        protected DAPopupMenu popupMenu;
 
        public abstract void parseLogPackage(LogPackage logPack);
-
+       
+       public void inputChartSeries(List<List<Object>> data) {}
+       
        public DAChartBoardItem createBoardItem(final DAChartBoard chartBoard) {
                DAChartBoardItem item = new DAChartBoardItem(chartBoard, chartName,
                                chartIcon, chartStyle);

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineChartManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineChartManager.java
index 5c3173e..5ad772f 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineChartManager.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineChartManager.java
@@ -29,14 +29,22 @@ package org.tizen.dynamicanalyzer.ui.timeline.common;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+
 import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.database.DBTable;
 import org.tizen.dynamicanalyzer.nl.ConfigureLabels;
 import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
 import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
 import org.tizen.dynamicanalyzer.swap.logparser.Logs;
 import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager;
+import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.swap.model.data.MemoryData;
+import org.tizen.dynamicanalyzer.swap.model.data.SystemData;
 import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
 import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
+import org.tizen.dynamicanalyzer.ui.timeline.ScreenShotDBTable;
+import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBInserter;
+import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable;
 import org.tizen.dynamicanalyzer.ui.timeline.chart.CPUChart;
 import org.tizen.dynamicanalyzer.ui.timeline.chart.CPUCoreChart;
 import org.tizen.dynamicanalyzer.ui.timeline.chart.CPUFrequencyChart;
@@ -60,8 +68,10 @@ import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
 import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
 import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
 import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
+import org.tizen.dynamicanalyzer.widgets.chartBoard.IDAChartSeriesMaker;
+
 
-public class TimelineChartManager extends PageDataManager {
+public class TimelineChartManager extends PageDataManager implements IDAChartSeriesMaker {
        private static TimelineChartManager instance = null;
 
        private boolean newCustomChart = false;
@@ -79,6 +89,21 @@ public class TimelineChartManager extends PageDataManager {
        private final LifecycleLogParser lifecycleLogParser = LifecycleLogParser
                        .getInstance();
 
+       /*
+        * Data for Refactoring
+        */
+       private SystemDataDBTable systemDataTable = null;
+       private ScreenShotDBTable screenShotDBTable = null;
+       private static final int MEM_API_TYPE_ALLOC = 0;
+       private static final int MEM_API_TYPE_FREE = 1;
+       private static final int MEM_API_TYPE_MANAGE = 2;
+       private static final int MEM_USER = 2;
+       private long allocByte = 0;
+       private HashMap<Long, Long> allocationSeriesDataSetMap = new HashMap<Long, Long>();
+       private ArrayList<List<Object>> systemDataList;
+       private ArrayList<List<Object>> screenShotList;
+       
+       
        public static TimelineChartManager getInstance() {
                if (instance == null) {
                        instance = new TimelineChartManager();
@@ -96,7 +121,11 @@ public class TimelineChartManager extends PageDataManager {
                
                deviceLogParser = new DeviceLogParser(this);
                customLogParser = new CustomLogParser(this);
-
+               
+               systemDataTable = new SystemDataDBTable();
+               addDBTable(systemDataTable);
+               systemDataList = new ArrayList<List<Object>>();
+               
                initChartMap(CPUChart.getInstance());
                initChartMap(CPUCoreChart.getInstance());
                initChartMap(CPUFrequencyChart.getInstance());
@@ -293,6 +322,10 @@ public class TimelineChartManager extends PageDataManager {
                loadSelectedChartList();
                customChartMap.clear();
                customLogParser.clear();
+               
+               allocByte = 0;
+               allocationSeriesDataSetMap.clear();
+               systemDataList.clear();
        }
 
        @Override
@@ -301,15 +334,18 @@ public class TimelineChartManager extends PageDataManager {
                        LogPackage pack = pollPack();
                        if (null == pack) // stop thread
                                break;
-
-                       Logs deviceLogs = pack
-                                       .getLogs(DataChannelConstants.MSG_DATA_SYSTEM);
-                       if (deviceLogs != null && !deviceLogs.getRawLogs().isEmpty()) {
+                       
+                       /*
+                        * 1. Make SystemDataTable column
+                        */
+                       Logs systemLogs = pack.getLogs(DataChannelConstants.MSG_DATA_SYSTEM);
+                       Logs memoryLogs = pack.getLogs(DataChannelConstants.MSG_PROBE_MEMORY);
+                       makeSystemDataTableData(systemLogs, memoryLogs);
+                       
+                       if (systemLogs != null && !systemLogs.getRawLogs().isEmpty()) {
                                deviceLogParser.parseLogPackage(pack);
                        }
 
-                       Logs memoryLogs = pack
-                                       .getLogs(DataChannelConstants.MSG_PROBE_MEMORY);
                        if (memoryLogs != null && !memoryLogs.getRawLogs().isEmpty()) {
                                HeapChart.getInstance().parseLogPackage(pack);
                        }
@@ -325,22 +361,170 @@ public class TimelineChartManager extends PageDataManager {
                        if (customLogs != null && !customLogs.getRawLogs().isEmpty()) {
                                customLogParser.parseLogPackage(pack);
                        }
-
+                       
+                       Logs screenShotLogs = pack.
+                                       getLogs(DataChannelConstants.MSG_PROBE_SCREENSHOT);
+                       if (screenShotLogs != null
+                                       && !screenShotLogs.getRawLogs().isEmpty()) {
+                               ScreenshotChart.getInstance().parseLogPackage(pack);
+                       }
+                       
+                       
                        Logs lifecycleLogs = pack
                                        .getLogs(DataChannelConstants.MSG_PROBE_LIFECYCLE);
                        if (lifecycleLogs != null && !lifecycleLogs.getRawLogs().isEmpty()) {
                                lifecycleLogParser.parseLogPackage(pack);
                        }
-
-                       Logs screenShotLogs = pack
-                                       .getLogs(DataChannelConstants.MSG_PROBE_SCREENSHOT);
-                       if (screenShotLogs != null
-                                       && !screenShotLogs.getRawLogs().isEmpty()) {
-                               ScreenshotChart.getInstance().parseLogPackage(pack);
-                       }
                }
 
                /* log for debug */
                System.out.println(getName() + " thread end!!"); //$NON-NLS-1$
        }
-}
\ No newline at end of file
+       
+       private void makeSystemDataTableData(Logs systemLogs, Logs memoryLogs) {
+               List<LogData> memoryLogList = memoryLogs == null ? null : memoryLogs.getRawLogs();
+               List<LogData> systemLogList = systemLogs == null ? null : systemLogs.getRawLogs();
+               
+               if (memoryLogList != null) {
+                               int size = memoryLogList.size();
+                               for (int i = 0; i < size; i++) {
+                                       MemoryData logData = (MemoryData) memoryLogList.get(i);
+                                       int memApiType = logData.getMemoryApiType();
+                                       int internalFlag = logData.getInternalCall();
+                                       long errorNo = logData.getErrno();
+       
+                                       if (errorNo == 0 && MEM_USER == internalFlag) {
+                                               if (MEM_API_TYPE_ALLOC == memApiType
+                                                               || MEM_API_TYPE_FREE == memApiType
+                                                               || MEM_API_TYPE_MANAGE == memApiType) {
+       
+                                                       addNewSeriesUserAllocData(memApiType, logData);
+                                               }
+                                       }
+                               }
+               }
+               if (systemLogList != null) {
+                       int size = systemLogList.size();
+                       for (int i = 0; i < size; i++) {
+                               SystemData log = (SystemData) systemLogList.get(i);
+                       
+                                       ArrayList<Object> dbSystemData = new ArrayList<Object>();
+                                       dbSystemData.add(new Long(log.getTime()));
+                                       dbSystemData.add(new Integer((int)log.getAppCpuUsage()));       // TODO change float
+                                       dbSystemData.add(new Integer(log.getProcessCount()));
+                                       dbSystemData.add(new Long(log.getTotalAllocSize() + allocByte));
+                                       dbSystemData.add(new Long(allocByte));
+                                       dbSystemData.add(new Integer(log.getVirtualMemory()));
+                                       dbSystemData.add(new Integer(log.getResidentMemory()));
+                                       dbSystemData.add(new Integer(log.getSharedMemory()));
+                                       dbSystemData.add(new Integer(log.getPssMemory()));
+                                       dbSystemData.add(new Long(log.getSystemMemoryTotal()));
+                                       dbSystemData.add(new Long(log.getSystemMemoryUsed()));
+                                       dbSystemData.add(new Integer(log.getNetworkSendSize()));
+                                       dbSystemData.add(new Integer(log.getNetworkReceiveSize()));
+                                       dbSystemData.add(new Integer(log.getWifi()));
+                                       dbSystemData.add(new Integer(log.getBtStatus()));
+                                       dbSystemData.add(new Integer(log.getGpsStatus()));
+                                       dbSystemData.add(new Integer(log.getBrightness()));
+                                       dbSystemData.add(new Integer(log.getDnet()));
+                                       dbSystemData.add(new Integer(log.getCamera()));
+                                       dbSystemData.add(new Integer(log.getSound()));  //20
+                                       dbSystemData.add(new Integer(log.getAudio()));
+                                       dbSystemData.add(new Integer(log.getVibration()));
+                                       dbSystemData.add(new Integer(log.getVoltage()));
+                                       dbSystemData.add(new Integer(log.getRssi()));
+                                       dbSystemData.add(new Integer(log.getVideo()));
+                                       dbSystemData.add(new Integer(log.getCall()));
+                                       dbSystemData.add(new Integer(log.getTotalUsedDrive()));
+                                       dbSystemData.add(new Integer(log.getDiskReadSize()));
+                                       dbSystemData.add(new Integer(log.getDiskReadSectorCount()));
+                                       dbSystemData.add(new Integer(log.getDiskWriteSize()));  //30
+                                       dbSystemData.add(new Integer(log.getDiskWrittenSectorCount()));
+                                       dbSystemData.add(new Integer(log.getEnergyUsage()));
+                                       
+                                       systemDataList.add(dbSystemData);
+                       }
+               }
+               
+                       @SuppressWarnings("unchecked")
+                       List<List<Object>> clist = (List<List<Object>>) systemDataList.clone();
+                       systemDataList.clear();
+                       
+                       SystemDataDBInserter.pushContextData(clist);
+                       SystemDataDBInserter.startThread();
+       }
+       
+       
+       private void addNewSeriesUserAllocData(int fdApiType, MemoryData log) {
+               long size = 0;
+
+               long address = log.getAddress();
+               if (address == 0) {
+                       return;
+               }
+
+               if (MEM_API_TYPE_ALLOC == fdApiType) {
+                       try {
+                               size = log.getSize();
+
+                               allocByte += size;
+                               allocationSeriesDataSetMap.put(address, size);
+                       } catch (NumberFormatException ne) {
+                               ne.printStackTrace();
+                       }
+               } else if (MEM_API_TYPE_FREE == fdApiType) {
+                       if (!allocationSeriesDataSetMap.containsKey(address)) {
+                               return;
+                       }
+                       size = allocationSeriesDataSetMap.get(address);
+
+                       allocByte -= size;
+               }
+       }
+       
+       public DBTable getSystemDataTable() {
+               return systemDataTable;
+       }
+       
+       public List<List<Object>> getSystemDataFromDB(long start, long end) {
+       String where = "where TIME BETWEEN " + start  + " AND " + end;
+       return systemDataTable.selectData(null, where);
+    }
+       
+       @Override
+       public void makeChartSeries(long startTime, long endTime) {
+               /*
+                * 1. Get DB data 
+                */
+               List<List<Object>> systemDBData = getSystemDataFromDB(startTime, endTime);
+               
+               /*
+                * 2. Make series of chart
+                */
+               if (systemDBData != null) {
+                       for (TimelineChart chart : chartList) {
+                               if (chart.getProbeType() == DataChannelConstants.MSG_DATA_SYSTEM) {
+                                       chart.inputChartSeries(systemDBData);
+                               }
+                       }
+               }
+       }
+}
+
+/*
+ * Logging DB data
+ */
+//System.err.println("\nstartTime : " + startTime + ", endTime : " + endTime);
+//if (systemDBData != null) {
+//     for (int i = 0; i < systemDBData.size(); i++) {
+//             List<Object> row = systemDBData.get(i);
+//             if (row != null) {
+//                 for (int j = 0; j < row.size(); j++) {
+//                             System.err.print(row.get(j) + ",");
+//                 }
+//                 System.err.println();
+//             }
+//     }
+//} else {
+//    System.err.println("systemDBData is null!!");
+//}

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineView.java
index d66670a..7b8bada 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineView.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineView.java
@@ -78,6 +78,7 @@ public class TimelineView extends DAViewComposite {
                contents.setBackground(ColorResources.WINDOW_BG_COLOR);
 
                chartBoard = new DAChartBoard(contents, "Timeline"); //$NON-NLS-1$
+               chartBoard.setChartSeriesMaker(timelineChartManager);
                chartBoard.setNameFont(FontResources.CHART_NAME_FONT);
                timelineChartManager.setChartTimelineChartBoard(chartBoard);
                chartBoard.setSelectable(false);