1 /*
2 * Copyright (C) 2023 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 "post_event_utils.h"
16
17 #include <unistd.h>
18
19 #include "hisysevent.h"
20 #include "ipc_skeleton.h"
21 #include "media_log.h"
22 namespace OHOS {
23 namespace Media {
24 using namespace std;
25
26 const string OPT_CREATE = "CREATE";
27 const string OPT_THUMB = "THUMB";
28 const string OPT_SCAN = "SCAN";
29 const string OPT_QUERY = "QUERY";
30 static constexpr char MEDIA_LIBRARY[] = "MEDIALIBRARY";
31
GetOptType(const uint32_t & optType)32 string PostEventUtils::GetOptType(const uint32_t &optType)
33 {
34 string type = "";
35 switch (optType) {
36 case OptType::CREATE:
37 type = OPT_CREATE;
38 break;
39 case OptType::THUMB:
40 type = OPT_THUMB;
41 break;
42 case OptType::SCAN:
43 type = OPT_SCAN;
44 break;
45 case OptType::QUERY:
46 type = OPT_QUERY;
47 break;
48 default:
49 break;
50 }
51 return type;
52 }
53
GetIntValue(const string & key,const VariantMap & map)54 int32_t PostEventUtils::GetIntValue(const string &key, const VariantMap &map)
55 {
56 int value = 0;
57 auto iter = map.find(key);
58 if (iter != map.end()) {
59 if (holds_alternative<int32_t>(iter->second)) {
60 return get<int32_t>(iter->second);
61 }
62 }
63 return value;
64 }
65
GetInt64Value(const string & key,const VariantMap & map)66 int64_t PostEventUtils::GetInt64Value(const string &key, const VariantMap &map)
67 {
68 int64_t value = 0;
69 auto iter = map.find(key);
70 if (iter != map.end()) {
71 if (holds_alternative<int64_t>(iter->second)) {
72 return get<int64_t>(iter->second);
73 }
74 }
75 return value;
76 }
77
GetStringValue(const string & key,const VariantMap & map)78 string PostEventUtils::GetStringValue(const string &key, const VariantMap &map)
79 {
80 string value;
81 auto iter = map.find(key);
82 if (iter != map.end()) {
83 if (holds_alternative<string>(iter->second)) {
84 return get<string>(iter->second);
85 }
86 }
87 return value;
88 }
89
PostFileOptError(const VariantMap & error)90 void PostEventUtils::PostFileOptError(const VariantMap &error)
91 {
92 uint32_t uid = getuid();
93 int ret = HiSysEventWrite(
94 MEDIA_LIBRARY,
95 "MEDIALIB_FILE_OPT_ERROR",
96 HiviewDFX::HiSysEvent::EventType::FAULT,
97 "UID", uid,
98 "ERR_FILE", GetStringValue(KEY_ERR_FILE, error),
99 "LINE", GetIntValue(KEY_ERR_LINE, error),
100 "ERROR_CODE", GetIntValue(KEY_ERR_CODE, error),
101 "FILE", GetStringValue(KEY_OPT_FILE, error),
102 "TYPE", GetOptType(GetIntValue(KEY_OPT_TYPE, error)),
103 "CALLING_ID", IPCSkeleton::GetCallingUid());
104 if (ret != 0) {
105 MEDIA_ERR_LOG("PostFileOptError error:%{public}d", ret);
106 }
107 }
108
PostDbOptError(const VariantMap & error)109 void PostEventUtils::PostDbOptError(const VariantMap &error)
110 {
111 uint32_t uid = getuid();
112 int ret = HiSysEventWrite(
113 MEDIA_LIBRARY,
114 "MEDIALIB_DB_OPT_ERROR",
115 HiviewDFX::HiSysEvent::EventType::FAULT,
116 "UID", uid,
117 "ERR_FILE", GetStringValue(KEY_ERR_FILE, error),
118 "LINE", GetIntValue(KEY_ERR_LINE, error),
119 "ERROR_CODE", GetIntValue(KEY_ERR_CODE, error),
120 "TYPE", GetOptType(GetIntValue(KEY_OPT_TYPE, error)),
121 "CALLING_ID", IPCSkeleton::GetCallingUid());
122 if (ret != 0) {
123 MEDIA_ERR_LOG("Failed to PostDbOptError error:%{public}d", ret);
124 }
125 }
126
PostDbUpgradeError(const VariantMap & error)127 void PostEventUtils::PostDbUpgradeError(const VariantMap &error)
128 {
129 int ret = HiSysEventWrite(
130 MEDIA_LIBRARY,
131 "MEDIALIB_DB_UPGRADE_ERROR",
132 HiviewDFX::HiSysEvent::EventType::FAULT,
133 "ERR_FILE", GetStringValue(KEY_ERR_FILE, error),
134 "LINE", GetIntValue(KEY_ERR_LINE, error));
135 if (ret != 0) {
136 MEDIA_ERR_LOG("Failed to PostDbUpgradeError err:%{public}d", ret);
137 }
138 }
139
PostThumbnailStat(const VariantMap & stat)140 void PostEventUtils::PostThumbnailStat(const VariantMap &stat)
141 {
142 uint32_t uid = getuid();
143 thumbnailTimes_++;
144 int ret = HiSysEventWrite(
145 MEDIA_LIBRARY,
146 "MEDIALIB_THUMBNAIL_STAT",
147 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
148 "UID", uid,
149 "TIMES", thumbnailTimes_,
150 "GNUMS", GetIntValue(KEY_GNUMS, stat),
151 "ANUMS", GetIntValue(KEY_ANUMS, stat));
152 if (ret != 0) {
153 MEDIA_ERR_LOG("Failed to PostThumbnailStat error:%{public}d ", ret);
154 }
155 }
156
PostDbUpgradeStat(const VariantMap & stat)157 void PostEventUtils::PostDbUpgradeStat(const VariantMap &stat)
158 {
159 int32_t preVersion = GetIntValue(KEY_PRE_VERSION, stat);
160 int32_t afterVersion = GetIntValue(KEY_AFTER_VERSION, stat);
161 dbUpgradeTimes_++;
162 int ret = HiSysEventWrite(
163 MEDIA_LIBRARY,
164 "MEDIALIB_DB_UPGRADE_STAT",
165 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
166 "PRE_VERSION", preVersion,
167 "AFTER_VERSION", afterVersion,
168 "COUNT", dbUpgradeTimes_);
169 if (ret != 0) {
170 MEDIA_ERR_LOG("PostDbUpgradeStat preVersion:%{public}d afterVersion:%{public}d error:%{public}d",
171 preVersion, afterVersion, ret);
172 }
173 }
174
PostSyncStat()175 void PostEventUtils::PostSyncStat()
176 {
177 syncTimes_++;
178 int ret = HiSysEventWrite(
179 MEDIA_LIBRARY,
180 "MEDIALIB_SYNC_STAT",
181 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
182 "TIMES", syncTimes_);
183 if (ret != 0) {
184 MEDIA_ERR_LOG("PostSyncStat ret:%{public}d", ret);
185 }
186 }
187
PostAgingStat(const VariantMap & stat)188 void PostEventUtils::PostAgingStat(const VariantMap &stat)
189 {
190 recycleTimes_++;
191 int ret = HiSysEventWrite(
192 MEDIA_LIBRARY,
193 "MEDIALIB_AGING_STAT",
194 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
195 "TIMES", recycleTimes_,
196 "COUNT", GetIntValue(KEY_COUNT, stat));
197 if (ret != 0) {
198 MEDIA_ERR_LOG("PostAgingStat error:%{public}d", ret);
199 }
200 }
201
PostMscFirstVisitStat(const VariantMap & stat)202 void PostEventUtils::PostMscFirstVisitStat(const VariantMap &stat)
203 {
204 string photoId = GetStringValue(KEY_PHOTO_ID, stat);
205 int64_t timeInterval = GetInt64Value(KEY_TIME_INTERVAL, stat);
206 int ret = HiSysEventWrite(
207 MEDIA_LIBRARY,
208 "MEDIALIB_MSC_FIRST_VISIT_STAT",
209 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
210 KEY_PHOTO_ID, photoId,
211 KEY_TIME_INTERVAL, timeInterval);
212 if (ret != 0) {
213 MEDIA_ERR_LOG("PostMscFirstVisitStat error:%{public}d", ret);
214 }
215 }
216
PostMscRequestPolicyStat(const VariantMap & stat)217 void PostEventUtils::PostMscRequestPolicyStat(const VariantMap &stat)
218 {
219 string callingPackage = GetStringValue(KEY_CALLING_PACKAGE, stat);
220 int32_t highQualityCount = GetIntValue(KEY_HIGH_QUALITY_COUNT, stat);
221 int32_t balanceQualityCount = GetIntValue(KEY_BALANCE_QUALITY_COUNT, stat);
222 int32_t emergencyQualityCount = GetIntValue(KEY_EMERGENCY_QUALITY_COUNT, stat);
223 int ret = HiSysEventWrite(
224 MEDIA_LIBRARY,
225 "MEDIALIB_MSC_REQUST_POLICY_STAT",
226 HiviewDFX::HiSysEvent::EventType::STATISTIC,
227 KEY_CALLING_PACKAGE, callingPackage,
228 KEY_HIGH_QUALITY_COUNT, highQualityCount,
229 KEY_BALANCE_QUALITY_COUNT, balanceQualityCount,
230 KEY_EMERGENCY_QUALITY_COUNT, emergencyQualityCount);
231 if (ret != 0) {
232 MEDIA_ERR_LOG("PostMscRequestPolicyStat error:%{public}d", ret);
233 }
234 }
235
PostMscTriggerRatioStat(const VariantMap & stat)236 void PostEventUtils::PostMscTriggerRatioStat(const VariantMap &stat)
237 {
238 int32_t thirdPartCount = GetIntValue(KEY_THIRD_PART_COUNT, stat);
239 int32_t autoCount = GetIntValue(KEY_AUTO_COUNT, stat);
240 int ret = HiSysEventWrite(
241 MEDIA_LIBRARY,
242 "MEDIALIB_MSC_TRIGGER_RATIO_STAT",
243 HiviewDFX::HiSysEvent::EventType::STATISTIC,
244 KEY_THIRD_PART_COUNT, thirdPartCount,
245 KEY_AUTO_COUNT, autoCount);
246 if (ret != 0) {
247 MEDIA_ERR_LOG("PostMscTriggerRatioStat error:%{public}d", ret);
248 }
249 }
250
PostMscTotalTimeCostStat(const VariantMap & stat)251 void PostEventUtils::PostMscTotalTimeCostStat(const VariantMap &stat)
252 {
253 string photoId = GetStringValue(KEY_PHOTO_ID, stat);
254 int64_t totalTimeCost = GetInt64Value(KEY_TOTAL_TIME_COST, stat);
255 int ret = HiSysEventWrite(
256 MEDIA_LIBRARY,
257 "MEDIALIB_MSC_TOTAL_TIME_STAT",
258 HiviewDFX::HiSysEvent::EventType::STATISTIC,
259 KEY_PHOTO_ID, photoId,
260 KEY_TOTAL_TIME_COST, totalTimeCost);
261 if (ret != 0) {
262 MEDIA_ERR_LOG("PostMscTotalTimeCostStat error:%{public}d", ret);
263 }
264 }
265
PostMscResultStat(const VariantMap & stat)266 void PostEventUtils::PostMscResultStat(const VariantMap &stat)
267 {
268 string photoId = GetStringValue(KEY_PHOTO_ID, stat);
269 int32_t result = GetIntValue(KEY_RESULT, stat);
270 int32_t mediaType = GetIntValue(KEY_MEDIA_TYPE, stat);
271 int ret = HiSysEventWrite(
272 MEDIA_LIBRARY,
273 "MEDIALIB_MSC_RESULT_STAT",
274 HiviewDFX::HiSysEvent::EventType::STATISTIC,
275 KEY_PHOTO_ID, photoId,
276 KEY_RESULT, result,
277 KEY_MEDIA_TYPE, mediaType);
278 if (ret != 0) {
279 MEDIA_ERR_LOG("PostMscResultStat error:%{public}d", ret);
280 }
281 }
282
PostDatabaseCorruption(const VariantMap & errMap)283 void PostEventUtils::PostDatabaseCorruption(const VariantMap &errMap)
284 {
285 string date = GetStringValue(KEY_DB_CORRUPT, errMap);
286 MEDIA_ERR_LOG("ReportDatabaseCorruption periodTime:%{public}s", date.c_str());
287 int ret = HiSysEventWrite(
288 MEDIA_LIBRARY,
289 "DATABASE_CORRUPTION_ERROR",
290 HiviewDFX::HiSysEvent::EventType::FAULT,
291 "DATE", date);
292 if (ret != 0) {
293 MEDIA_ERR_LOG("ReportDatabaseCorruption error:%{public}d", ret);
294 }
295 }
296
PostErrorProcess(const uint32_t & errType,const VariantMap & error)297 void PostEventUtils::PostErrorProcess(const uint32_t &errType, const VariantMap &error)
298 {
299 switch (errType) {
300 case ErrType::FILE_OPT_ERR:
301 case ErrType::DB_OPT_ERR:
302 case ErrType::DB_UPGRADE_ERR:
303 break;
304 case ErrType::DB_CORRUPT_ERR:
305 PostDatabaseCorruption(error);
306 break;
307 default:
308 PostFileOptError(error);
309 PostDbOptError(error);
310 PostDbUpgradeError(error);
311 break;
312 }
313 }
314
PostCloudEnhanceStat(const VariantMap & stat)315 void PostEventUtils::PostCloudEnhanceStat(const VariantMap &stat)
316 {
317 std::string photoId = GetStringValue(KEY_PHOTO_ID, stat);
318 std::string completeType = GetStringValue(KEY_CLOUD_ENHANCEMENT_COMPLETE_TYPE, stat);
319 int64_t totalTimeCost = GetInt64Value(KEY_TOTAL_TIME_COST, stat);
320 int ret = HiSysEventWrite(
321 MEDIA_LIBRARY,
322 "MEDIALIB_CLOUDENHANCEMENT_STAT",
323 HiviewDFX::HiSysEvent::EventType::STATISTIC,
324 KEY_PHOTO_ID, photoId,
325 KEY_TOTAL_TIME_COST, totalTimeCost,
326 KEY_CLOUD_ENHANCEMENT_COMPLETE_TYPE, completeType);
327 if (ret != 0) {
328 MEDIA_ERR_LOG("PostCloudEnhanceStat:%{public}d", ret);
329 }
330 }
331
332
PostStatProcess(const uint32_t & statType,const VariantMap & stat)333 void PostEventUtils::PostStatProcess(const uint32_t &statType, const VariantMap &stat)
334 {
335 switch (statType) {
336 case StatType::THUMBNAIL_STAT:
337 case StatType::DB_UPGRADE_STAT:
338 case StatType::SYNC_STAT:
339 case StatType::AGING_STAT:
340 break;
341 case StatType::MSC_FIRST_VISIT_STAT:
342 PostMscFirstVisitStat(stat);
343 break;
344 case StatType::MSC_REQUEST_POLICY_STAT:
345 PostMscRequestPolicyStat(stat);
346 break;
347 case StatType::MSC_TRIGGER_RATIO_STAT:
348 PostMscTriggerRatioStat(stat);
349 break;
350 case StatType::MSC_TOTAL_TIME_COST_STAT:
351 PostMscTotalTimeCostStat(stat);
352 break;
353 case StatType::MSC_RESULT_STAT:
354 PostMscResultStat(stat);
355 break;
356 case StatType::CLOUD_ENHANCEMENT_GET_COUNT_STAT:
357 PostCloudEnhanceStat(stat);
358 break;
359 default:
360 PostThumbnailStat(stat);
361 PostDbUpgradeStat(stat);
362 PostSyncStat();
363 PostAgingStat(stat);
364 break;
365 }
366 }
367 } // namespace Media
368 } // namespace OHOS
369