1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "clock_filter.h"
16 #include "hi_sysevent_measure_filter.h"
17 #include "htrace_event_parser.h"
18 #include "htrace_hisysevent_parser.h"
19 #include "htrace_parser.h"
20 #include "process_filter.h"
21 #include "stat_filter.h"
22 namespace SysTuning {
23 namespace TraceStreamer {
HtraceHisyseventParser(TraceDataCache * dataCache,const TraceStreamerFilters * ctx)24 HtraceHisyseventParser::HtraceHisyseventParser(TraceDataCache* dataCache, const TraceStreamerFilters* ctx)
25 : HtracePluginTimeParser(dataCache, ctx)
26 {
27 }
~HtraceHisyseventParser()28 HtraceHisyseventParser::~HtraceHisyseventParser()
29 {
30 TS_LOGI("hisysevent ts MIN:%llu, MAX:%llu", static_cast<unsigned long long>(GetPluginStartTime()),
31 static_cast<unsigned long long>(GetPluginEndTime()));
32 TS_LOGI("hisysevent real ts MIN:%llu, MAX:%llu", static_cast<unsigned long long>(MinTs()),
33 static_cast<unsigned long long>(MaxTs()));
34 }
35
JGetData(json & jMessage,JsonData & jData,size_t & maxArraySize,std::vector<size_t> & noArrayIndex,std::vector<size_t> & arrayIndex)36 int32_t HtraceHisyseventParser::JGetData(json& jMessage,
37 JsonData& jData,
38 size_t& maxArraySize,
39 std::vector<size_t>& noArrayIndex,
40 std::vector<size_t>& arrayIndex)
41 {
42 streamFilters_->statFilter_->IncreaseStat(TRACE_HISYSEVENT, STAT_EVENT_RECEIVED);
43 for (auto i = jMessage.begin(); i != jMessage.end(); i++) {
44 if (i.key() == "name_") {
45 if (find(eventsAccordingAppNames.begin(), eventsAccordingAppNames.end(), i.value()) ==
46 eventsAccordingAppNames.end()) {
47 streamFilters_->statFilter_->IncreaseStat(TRACE_HISYSEVENT, STAT_EVENT_NOTMATCH);
48 std::cout << "find comming" << std::endl;
49 return -1;
50 }
51 jData.eventSource = i.value();
52 continue;
53 }
54 if (i.key() == "time_") {
55 jData.timestamp = i.value();
56 continue;
57 }
58 if (i.key() == "tag_" && i.value() != "PowerStats") {
59 streamFilters_->statFilter_->IncreaseStat(TRACE_HISYSEVENT, STAT_EVENT_DATA_INVALID);
60 return -1;
61 }
62 if (i.key() == "APPNAME") {
63 jData.appName.assign(i.value().begin(), i.value().end());
64 }
65 if (i.value().is_array()) {
66 maxArraySize = std::max(maxArraySize, i.value().size());
67 arrayIndex.push_back(jData.key.size());
68 } else {
69 noArrayIndex.push_back(jData.key.size());
70 }
71 jData.key.push_back(i.key());
72 jData.value.push_back(i.value());
73 }
74 return 0;
75 }
76
NoArrayDataParse(JsonData jData,std::vector<size_t> noArrayIndex,DataIndex eventSourceIndex,uint64_t serial)77 void HtraceHisyseventParser::NoArrayDataParse(JsonData jData,
78 std::vector<size_t> noArrayIndex,
79 DataIndex eventSourceIndex,
80 uint64_t serial)
81 {
82 for (auto itor = noArrayIndex.begin(); itor != noArrayIndex.end(); itor++) {
83 auto value = jData.value[*itor];
84 auto key = jData.key[*itor];
85 streamFilters_->hiSysEventMeasureFilter_->GetOrCreateFilterId(eventSourceIndex);
86 DataIndex keyIndex = traceDataCache_->GetDataIndex(key);
87 if (value.is_string()) {
88 std::string strValue = value;
89 DataIndex valueIndex = traceDataCache_->GetDataIndex(strValue);
90 streamFilters_->hiSysEventMeasureFilter_->AppendNewValue(serial, jData.timestamp,
91 eventSourceIndex, keyIndex, 1, 0, valueIndex);
92 } else {
93 double valueIndex = value;
94 streamFilters_->hiSysEventMeasureFilter_->AppendNewValue(serial, jData.timestamp,
95 eventSourceIndex, keyIndex, 0, valueIndex, 0);
96 }
97 }
98 }
ArrayDataParse(JsonData jData,std::vector<size_t> arrayIndex,DataIndex eventSourceIndex,size_t maxArraySize,uint64_t serial)99 void HtraceHisyseventParser::ArrayDataParse(JsonData jData,
100 std::vector<size_t> arrayIndex,
101 DataIndex eventSourceIndex,
102 size_t maxArraySize,
103 uint64_t serial)
104 {
105 for (int j = 0; j < maxArraySize; j++) {
106 for (auto itor = arrayIndex.begin(); itor != arrayIndex.end(); itor++) {
107 auto value = jData.value[*itor][j];
108 std::string key = jData.key[*itor];
109 DataIndex keyIndex = traceDataCache_->GetDataIndex(key);
110 streamFilters_->hiSysEventMeasureFilter_->GetOrCreateFilterId(eventSourceIndex);
111 if (value.is_number()) {
112 double valueIndex = value;
113 streamFilters_->hiSysEventMeasureFilter_->AppendNewValue(serial, jData.timestamp,
114 eventSourceIndex, keyIndex, 0, valueIndex, 0);
115 } else if (value.is_string()) {
116 std::string strValue = value;
117 DataIndex valueIndex = traceDataCache_->GetDataIndex(strValue);
118 streamFilters_->hiSysEventMeasureFilter_->AppendNewValue(serial, jData.timestamp,
119 eventSourceIndex, keyIndex, 1, 0, valueIndex);
120 }
121 }
122 }
123 }
CommonDataParser(JsonData jData,DataIndex eventSourceIndex,uint64_t serial)124 void HtraceHisyseventParser::CommonDataParser(JsonData jData, DataIndex eventSourceIndex, uint64_t serial)
125 {
126 for (int j = 0; j < jData.key.size(); j++) {
127 std::string key = jData.key[j];
128 auto value = jData.value[j];
129 DataIndex keyIndex = traceDataCache_->GetDataIndex(key);
130 streamFilters_->hiSysEventMeasureFilter_->GetOrCreateFilterId(eventSourceIndex);
131 if (value.is_string()) {
132 std::string strValue = value;
133 DataIndex valueIndex = traceDataCache_->GetDataIndex(strValue);
134 streamFilters_->hiSysEventMeasureFilter_->AppendNewValue(serial, jData.timestamp,
135 eventSourceIndex, keyIndex, 1, 0, valueIndex);
136 } else {
137 double valueIndex = value;
138 streamFilters_->hiSysEventMeasureFilter_->AppendNewValue(serial, jData.timestamp, eventSourceIndex,
139 keyIndex, 0, valueIndex, 0);
140 }
141 }
142 }
Finish()143 void HtraceHisyseventParser::Finish()
144 {
145 traceDataCache_->MixTraceTime(GetPluginStartTime(), GetPluginEndTime());
146 TS_LOGI("--------Parse end--------");
147 }
148
149 static std::stringstream ss;
Parse(HisyseventInfo & tracePacket,uint64_t ts)150 void HtraceHisyseventParser::Parse(HisyseventInfo& tracePacket, uint64_t ts)
151 {
152 if (isDeviceState) {
153 streamFilters_->hiSysEventMeasureFilter_->AppendNewValue(
154 tracePacket.device_state().brightness_state(), tracePacket.device_state().bt_state(),
155 tracePacket.device_state().location_state(), tracePacket.device_state().wifi_state(),
156 tracePacket.device_state().volume_state().stream_default(),
157 tracePacket.device_state().volume_state().voice_call(), tracePacket.device_state().volume_state().music(),
158 tracePacket.device_state().volume_state().stream_ring(), tracePacket.device_state().volume_state().media(),
159 tracePacket.device_state().volume_state().voice_assistant(),
160 tracePacket.device_state().volume_state().system(), tracePacket.device_state().volume_state().alarm(),
161 tracePacket.device_state().volume_state().notification(),
162 tracePacket.device_state().volume_state().bluetoolth_sco(),
163 tracePacket.device_state().volume_state().enforced_audible(),
164 tracePacket.device_state().volume_state().stream_dtmf(),
165 tracePacket.device_state().volume_state().stream_tts(),
166 tracePacket.device_state().volume_state().accessibility(),
167 tracePacket.device_state().volume_state().recording(),
168 tracePacket.device_state().volume_state().stream_all());
169 isDeviceState = false;
170 }
171 json jMessage;
172 for (int i = 0; i < tracePacket.info_size(); i++) {
173 if (tracePacket.info(i).raw_content().front() != '{' || tracePacket.info(i).raw_content().back() != '}') {
174 continue;
175 }
176 ss << tracePacket.info(i).raw_content();
177 ss >> jMessage;
178 size_t maxArraySize = 0;
179 JsonData jData;
180 std::vector<size_t> noArrayIndex = {};
181 std::vector<size_t> arrayIndex = {};
182 if (JGetData(jMessage, jData, maxArraySize, noArrayIndex, arrayIndex) < 0) {
183 TS_LOGI("Json data acquisition failed");
184 continue;
185 }
186 uint64_t serial = tracePacket.info(i).id();
187 DataIndex eventSourceIndex = traceDataCache_->GetDataIndex(jData.eventSource);
188 jData.timestamp *= MSEC_TO_NS;
189 auto newTimeStamp = streamFilters_->clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME, jData.timestamp);
190 UpdatePluginTimeRange(TS_CLOCK_BOOTTIME, jData.timestamp, newTimeStamp);
191 jData.timestamp = newTimeStamp;
192 if (maxArraySize) {
193 NoArrayDataParse(jData, noArrayIndex, eventSourceIndex, serial);
194 ArrayDataParse(jData, arrayIndex, eventSourceIndex, maxArraySize, serial);
195 } else {
196 CommonDataParser(jData, eventSourceIndex, serial);
197 }
198 }
199 }
200 } // namespace TraceStreamer
201 } // namespace SysTuning
202