1 /*
2 * Copyright (c) 2025 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
16 #include "export_json_file_builder.h"
17
18 #include "event_export_util.h"
19 #include "focused_event_util.h"
20 #include "hiview_logger.h"
21 #include "parameter.h"
22 #include "parameter_ex.h"
23
24 namespace OHOS {
25 namespace HiviewDFX {
26 DEFINE_LOG_TAG("HiView-EventExportFlow");
27 namespace {
28 constexpr char H_HEADER_KEY[] = "HEADER";
29 constexpr char H_VERSION_KEY[] = "VERSION";
30 constexpr char H_MSG_ID_KEY[] = "MESSAGE_ID";
31 constexpr char H_MANUFACTURE_KEY[] = "MANUFACTURER";
32 constexpr char H_NAME_KEY[] = "NAME";
33 constexpr char H_BRAND_KEY[] = "BRAND";
34 constexpr char H_DEVICE_KEY[] = "DEVICE";
35 constexpr char H_ID_KEY[] = "ID";
36 constexpr char H_MODEL_KEY[] = "MODEL";
37 constexpr char H_CATEGORY_KEY[] = "CATEGORY";
38 constexpr char H_SYSTEM_KEY[] = "SYSTEM";
39 constexpr char H_OHOS_VER_KEY[] = "OHOS_VER";
40 constexpr char H_PATCH_VER_KEY[] = "PATCH_VER";
41 constexpr char DOMAINS_KEY[] = "DOMAINS";
42 constexpr char DOMAIN_INFO_KEY[] = "DOMAIN_INFO";
43 constexpr char EVENTS_KEY[] = "EVENTS";
44 constexpr char DATA_KEY[] = "DATA";
45 constexpr char DEFAULT_MSG_ID[] = "00000000000000000000000000000000";
46 constexpr char CUR_HEADER_VERSION[] = "1.0";
47
CreateHeaderJsonObj()48 cJSON* CreateHeaderJsonObj()
49 {
50 cJSON* header = cJSON_CreateObject();
51 if (header == nullptr) {
52 HIVIEW_LOGE("failed to create header json object");
53 return nullptr;
54 }
55 cJSON_AddStringToObject(header, H_VERSION_KEY, CUR_HEADER_VERSION);
56 cJSON_AddStringToObject(header, H_MSG_ID_KEY, DEFAULT_MSG_ID);
57 return header;
58 }
59
CreateManufacturerJsonObj()60 cJSON* CreateManufacturerJsonObj()
61 {
62 cJSON* manufacturer = cJSON_CreateObject();
63 if (manufacturer == nullptr) {
64 HIVIEW_LOGE("failed to create manufacturer json object");
65 return nullptr;
66 }
67 cJSON_AddStringToObject(manufacturer, H_NAME_KEY, Parameter::GetManufactureStr().c_str());
68 cJSON_AddStringToObject(manufacturer, H_BRAND_KEY, Parameter::GetBrandStr().c_str());
69 return manufacturer;
70 }
71
CreateDeviceJsonObj()72 cJSON* CreateDeviceJsonObj()
73 {
74 cJSON* device = cJSON_CreateObject();
75 if (device == nullptr) {
76 HIVIEW_LOGE("failed to create device json object");
77 return nullptr;
78 }
79 cJSON_AddStringToObject(device, H_ID_KEY, EventExportUtil::GetDeviceId().c_str());
80 cJSON_AddStringToObject(device, H_MODEL_KEY, Parameter::GetProductModelStr().c_str());
81 cJSON_AddStringToObject(device, H_NAME_KEY, Parameter::GetMarketNameStr().c_str());
82 cJSON_AddStringToObject(device, H_CATEGORY_KEY, Parameter::GetDeviceTypeStr().c_str());
83 return device;
84 }
85
CreateSystemObj(const EventVersion & eventVersion)86 cJSON* CreateSystemObj(const EventVersion& eventVersion)
87 {
88 cJSON* system = cJSON_CreateObject();
89 if (system == nullptr) {
90 HIVIEW_LOGE("failed to create system json object");
91 return nullptr;
92 }
93 cJSON_AddStringToObject(system, H_VERSION_KEY, eventVersion.systemVersion.c_str());
94 cJSON_AddStringToObject(system, H_OHOS_VER_KEY, Parameter::GetSysVersionDetailsStr().c_str());
95 cJSON_AddStringToObject(system, H_PATCH_VER_KEY, eventVersion.patchVersion.c_str());
96 return system;
97 }
98
CreateEventsJsonArray(const std::string & domain,const std::vector<std::pair<std::string,std::string>> & events)99 cJSON* CreateEventsJsonArray(const std::string& domain,
100 const std::vector<std::pair<std::string, std::string>>& events)
101 {
102 // events
103 cJSON* eventsJsonArray = cJSON_CreateArray();
104 if (eventsJsonArray == nullptr) {
105 HIVIEW_LOGE("failed to create events json array");
106 return nullptr;
107 }
108 cJSON* dataJsonArray = cJSON_CreateArray();
109 if (dataJsonArray == nullptr) {
110 HIVIEW_LOGE("failed to create data json array");
111 cJSON_Delete(eventsJsonArray);
112 return nullptr;
113 }
114 for (const auto& event : events) {
115 cJSON* eventItem = cJSON_Parse(event.second.c_str());
116 if (FocusedEventUtil::IsFocusedEvent(domain, event.first)) {
117 HIVIEW_LOGI("write event to json: [%{public}s|%{public}s]", domain.c_str(),
118 event.first.c_str());
119 }
120 if (eventItem == nullptr) {
121 HIVIEW_LOGW("failed to create json for event: [%{public}s|%{public}s]", domain.c_str(),
122 event.first.c_str());
123 continue;
124 }
125 cJSON_AddItemToArray(dataJsonArray, eventItem);
126 }
127 cJSON* anonymousJsonObj = cJSON_CreateObject();
128 if (anonymousJsonObj == nullptr) {
129 HIVIEW_LOGE("failed to create anonymousJsonObj json object");
130 cJSON_Delete(dataJsonArray);
131 cJSON_Delete(eventsJsonArray);
132 return nullptr;
133 }
134 cJSON_AddItemToObjectCS(anonymousJsonObj, DATA_KEY, dataJsonArray);
135 cJSON_AddItemToArray(eventsJsonArray, anonymousJsonObj);
136 return eventsJsonArray;
137 }
138
CreateDomainsJson(const CachedEventMap & sysEvents)139 cJSON* CreateDomainsJson(const CachedEventMap& sysEvents)
140 {
141 cJSON* domainsArrayJson = cJSON_CreateArray();
142 if (domainsArrayJson == nullptr) {
143 HIVIEW_LOGE("failed to create json array");
144 return nullptr;
145 }
146 for (const auto& sysEvent : sysEvents) {
147 cJSON* domainJsonObj = cJSON_CreateObject();
148 if (domainJsonObj == nullptr) {
149 continue;
150 }
151 // domain info
152 cJSON* domainInfoJsonObj = cJSON_CreateObject();
153 if (domainInfoJsonObj == nullptr) {
154 HIVIEW_LOGE("failed to create domain info json object");
155 cJSON_Delete(domainJsonObj);
156 continue;
157 }
158 cJSON_AddStringToObject(domainInfoJsonObj, H_NAME_KEY, sysEvent.first.c_str());
159 cJSON_AddItemToObjectCS(domainJsonObj, DOMAIN_INFO_KEY, domainInfoJsonObj);
160 cJSON* eventsJsonObj = CreateEventsJsonArray(sysEvent.first, sysEvent.second);
161 if (eventsJsonObj == nullptr) {
162 HIVIEW_LOGE("failed to create json object for event array");
163 cJSON_Delete(domainJsonObj);
164 continue;
165 }
166 cJSON_AddItemToObjectCS(domainJsonObj, EVENTS_KEY, eventsJsonObj);
167 cJSON_AddItemToArray(domainsArrayJson, domainJsonObj);
168 }
169 return domainsArrayJson;
170 }
171
PersistJsonStr(cJSON * root,std::string & ret)172 bool PersistJsonStr(cJSON* root, std::string& ret)
173 {
174 char* parsedJsonStr = cJSON_PrintUnformatted(root);
175 if (parsedJsonStr == nullptr) {
176 HIVIEW_LOGE("formatted json str is null");
177 return false;
178 }
179 ret = std::string(parsedJsonStr);
180 cJSON_free(parsedJsonStr);
181 return true;
182 }
183 }
184
Build(const CachedEventMap & eventMap,std::string & buildStr)185 bool ExportJsonFileBuilder::Build(const CachedEventMap& eventMap, std::string& buildStr)
186 {
187 cJSON* root = cJSON_CreateObject();
188 if (root == nullptr) {
189 HIVIEW_LOGE("failed to create event json root");
190 return false;
191 }
192
193 if (!BuildHeader(root)) {
194 HIVIEW_LOGE("failed to build event json file header");
195 cJSON_Delete(root);
196 return false;
197 }
198 if (!BuildContent(root, eventMap)) {
199 HIVIEW_LOGE("failed to build event json file content");
200 cJSON_Delete(root);
201 return false;
202 }
203 bool peristRet = PersistJsonStr(root, buildStr);
204 cJSON_Delete(root);
205 return peristRet;
206 }
207
BuildHeader(cJSON * root)208 bool ExportJsonFileBuilder::BuildHeader(cJSON* root)
209 {
210 // add header
211 auto headerObj = CreateHeaderJsonObj();
212 if (headerObj == nullptr) {
213 return false;
214 }
215 cJSON_AddItemToObjectCS(root, H_HEADER_KEY, headerObj);
216 // add manufacturer
217 auto manufacturerObj = CreateManufacturerJsonObj();
218 if (manufacturerObj == nullptr) {
219 return false;
220 }
221 cJSON_AddItemToObjectCS(root, H_MANUFACTURE_KEY, manufacturerObj);
222 // add device info
223 auto deviceObj = CreateDeviceJsonObj();
224 if (deviceObj == nullptr) {
225 return false;
226 }
227 cJSON_AddItemToObjectCS(root, H_DEVICE_KEY, deviceObj);
228 // add system version info
229 auto systemObj = CreateSystemObj(eventVersion_);
230 if (systemObj == nullptr) {
231 return false;
232 }
233 cJSON_AddItemToObjectCS(root, H_SYSTEM_KEY, systemObj);
234 return true;
235 }
236
BuildContent(cJSON * root,const CachedEventMap & eventMap)237 bool ExportJsonFileBuilder::BuildContent(cJSON* root, const CachedEventMap& eventMap)
238 {
239 // add domains
240 cJSON* domainsJson = CreateDomainsJson(eventMap);
241 if (domainsJson == nullptr) {
242 return false;
243 }
244 cJSON_AddItemToObjectCS(root, DOMAINS_KEY, domainsJson);
245 return true;
246 }
247 } // HiviewDFX
248 } // OHOS