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 int ret = HiSysEventWrite(
271 MEDIA_LIBRARY,
272 "MEDIALIB_MSC_RESULT_STAT",
273 HiviewDFX::HiSysEvent::EventType::STATISTIC,
274 KEY_PHOTO_ID, photoId,
275 KEY_RESULT, result);
276 if (ret != 0) {
277 MEDIA_ERR_LOG("PostMscResultStat error:%{public}d", ret);
278 }
279 }
280
PostErrorProcess(const uint32_t & errType,const VariantMap & error)281 void PostEventUtils::PostErrorProcess(const uint32_t &errType, const VariantMap &error)
282 {
283 switch (errType) {
284 case ErrType::FILE_OPT_ERR:
285 case ErrType::DB_OPT_ERR:
286 case ErrType::DB_UPGRADE_ERR:
287 break;
288 default:
289 PostFileOptError(error);
290 PostDbOptError(error);
291 PostDbUpgradeError(error);
292 break;
293 }
294 }
295
PostStatProcess(const uint32_t & statType,const VariantMap & stat)296 void PostEventUtils::PostStatProcess(const uint32_t &statType, const VariantMap &stat)
297 {
298 switch (statType) {
299 case StatType::THUMBNAIL_STAT:
300 case StatType::DB_UPGRADE_STAT:
301 case StatType::SYNC_STAT:
302 case StatType::AGING_STAT:
303 break;
304 case StatType::MSC_FIRST_VISIT_STAT:
305 PostMscFirstVisitStat(stat);
306 break;
307 case StatType::MSC_REQUEST_POLICY_STAT:
308 PostMscRequestPolicyStat(stat);
309 break;
310 case StatType::MSC_TRIGGER_RATIO_STAT:
311 PostMscTriggerRatioStat(stat);
312 break;
313 case StatType::MSC_TOTAL_TIME_COST_STAT:
314 PostMscTotalTimeCostStat(stat);
315 break;
316 case StatType::MSC_RESULT_STAT:
317 PostMscResultStat(stat);
318 break;
319 default:
320 PostThumbnailStat(stat);
321 PostDbUpgradeStat(stat);
322 PostSyncStat();
323 PostAgingStat(stat);
324 break;
325 }
326 }
327 } // namespace Media
328 } // namespace OHOS
329