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 #include <set>
19
20 #include "hisysevent.h"
21 #include "ipc_skeleton.h"
22 #include "media_log.h"
23 namespace OHOS {
24 namespace Media {
25 using namespace std;
26
27 const string OPT_CREATE = "CREATE";
28 const string OPT_THUMB = "THUMB";
29 const string OPT_SCAN = "SCAN";
30 const string OPT_QUERY = "QUERY";
31 static constexpr char MEDIA_LIBRARY[] = "MEDIALIBRARY";
32
GetOptType(const uint32_t & optType)33 string PostEventUtils::GetOptType(const uint32_t &optType)
34 {
35 string type = "";
36 switch (optType) {
37 case OptType::CREATE:
38 type = OPT_CREATE;
39 break;
40 case OptType::THUMB:
41 type = OPT_THUMB;
42 break;
43 case OptType::SCAN:
44 type = OPT_SCAN;
45 break;
46 case OptType::QUERY:
47 type = OPT_QUERY;
48 break;
49 default:
50 break;
51 }
52 return type;
53 }
54
GetIntValue(const string & key,const VariantMap & map)55 int32_t PostEventUtils::GetIntValue(const string &key, const VariantMap &map)
56 {
57 int value = 0;
58 auto iter = map.find(key);
59 if (iter != map.end()) {
60 if (holds_alternative<int32_t>(iter->second)) {
61 return get<int32_t>(iter->second);
62 }
63 }
64 return value;
65 }
66
GetInt64Value(const string & key,const VariantMap & map)67 int64_t PostEventUtils::GetInt64Value(const string &key, const VariantMap &map)
68 {
69 int64_t value = 0;
70 auto iter = map.find(key);
71 if (iter != map.end()) {
72 if (holds_alternative<int64_t>(iter->second)) {
73 return get<int64_t>(iter->second);
74 }
75 }
76 return value;
77 }
78
GetStringValue(const string & key,const VariantMap & map)79 string PostEventUtils::GetStringValue(const string &key, const VariantMap &map)
80 {
81 string value;
82 auto iter = map.find(key);
83 if (iter != map.end()) {
84 if (holds_alternative<string>(iter->second)) {
85 return get<string>(iter->second);
86 }
87 }
88 return value;
89 }
90
PostFileOptError(const VariantMap & error)91 void PostEventUtils::PostFileOptError(const VariantMap &error)
92 {
93 uint32_t uid = getuid();
94 int ret = HiSysEventWrite(
95 MEDIA_LIBRARY,
96 "MEDIALIB_FILE_OPT_ERROR",
97 HiviewDFX::HiSysEvent::EventType::FAULT,
98 "UID", uid,
99 "ERR_FILE", GetStringValue(KEY_ERR_FILE, error),
100 "LINE", GetIntValue(KEY_ERR_LINE, error),
101 "ERROR_CODE", GetIntValue(KEY_ERR_CODE, error),
102 "FILE", GetStringValue(KEY_OPT_FILE, error),
103 "TYPE", GetOptType(GetIntValue(KEY_OPT_TYPE, error)),
104 "CALLING_ID", IPCSkeleton::GetCallingUid());
105 if (ret != 0) {
106 MEDIA_ERR_LOG("PostFileOptError error:%{public}d", ret);
107 }
108 }
109
PostRecoveryOptError(const VariantMap & error)110 void PostEventUtils::PostRecoveryOptError(const VariantMap &error)
111 {
112 int ret = HiSysEventWrite(
113 MEDIA_LIBRARY,
114 "MEDIALIB_META_RECOVERY_ERROR",
115 HiviewDFX::HiSysEvent::EventType::FAULT,
116 "ERR_FILE", GetStringValue(KEY_ERR_FILE, error),
117 "LINE", GetIntValue(KEY_ERR_LINE, error),
118 "ERROR_CODE", GetIntValue(KEY_ERR_CODE, error),
119 "TYPE", GetOptType(GetIntValue(KEY_OPT_TYPE, error)));
120 if (ret != 0) {
121 MEDIA_ERR_LOG("PostFileOptError error:%{public}d", ret);
122 }
123 }
124
PostDbOptError(const VariantMap & error)125 void PostEventUtils::PostDbOptError(const VariantMap &error)
126 {
127 uint32_t uid = getuid();
128 int ret = HiSysEventWrite(
129 MEDIA_LIBRARY,
130 "MEDIALIB_DB_OPT_ERROR",
131 HiviewDFX::HiSysEvent::EventType::FAULT,
132 "UID", uid,
133 "ERR_FILE", GetStringValue(KEY_ERR_FILE, error),
134 "LINE", GetIntValue(KEY_ERR_LINE, error),
135 "ERROR_CODE", GetIntValue(KEY_ERR_CODE, error),
136 "TYPE", GetOptType(GetIntValue(KEY_OPT_TYPE, error)),
137 "CALLING_ID", IPCSkeleton::GetCallingUid());
138 if (ret != 0) {
139 MEDIA_ERR_LOG("Failed to PostDbOptError error:%{public}d", ret);
140 }
141 }
142
PostDbUpgradeError(const VariantMap & error)143 void PostEventUtils::PostDbUpgradeError(const VariantMap &error)
144 {
145 int ret = HiSysEventWrite(
146 MEDIA_LIBRARY,
147 "MEDIALIB_DB_UPGRADE_ERROR",
148 HiviewDFX::HiSysEvent::EventType::FAULT,
149 "ERR_FILE", GetStringValue(KEY_ERR_FILE, error),
150 "LINE", GetIntValue(KEY_ERR_LINE, error));
151 if (ret != 0) {
152 MEDIA_ERR_LOG("Failed to PostDbUpgradeError err:%{public}d", ret);
153 }
154 }
155
PostThumbnailStat(const VariantMap & stat)156 void PostEventUtils::PostThumbnailStat(const VariantMap &stat)
157 {
158 uint32_t uid = getuid();
159 thumbnailTimes_++;
160 int ret = HiSysEventWrite(
161 MEDIA_LIBRARY,
162 "MEDIALIB_THUMBNAIL_STAT",
163 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
164 "UID", uid,
165 "TIMES", thumbnailTimes_,
166 "GNUMS", GetIntValue(KEY_GNUMS, stat),
167 "ANUMS", GetIntValue(KEY_ANUMS, stat));
168 if (ret != 0) {
169 MEDIA_ERR_LOG("Failed to PostThumbnailStat error:%{public}d ", ret);
170 }
171 }
172
PostDbUpgradeStat(const VariantMap & stat)173 void PostEventUtils::PostDbUpgradeStat(const VariantMap &stat)
174 {
175 int32_t preVersion = GetIntValue(KEY_PRE_VERSION, stat);
176 int32_t afterVersion = GetIntValue(KEY_AFTER_VERSION, stat);
177 dbUpgradeTimes_++;
178 int ret = HiSysEventWrite(
179 MEDIA_LIBRARY,
180 "MEDIALIB_DB_UPGRADE_STAT",
181 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
182 "PRE_VERSION", preVersion,
183 "AFTER_VERSION", afterVersion,
184 "COUNT", dbUpgradeTimes_);
185 if (ret != 0) {
186 MEDIA_ERR_LOG("PostDbUpgradeStat preVersion:%{public}d afterVersion:%{public}d error:%{public}d",
187 preVersion, afterVersion, ret);
188 }
189 }
190
PostSyncStat()191 void PostEventUtils::PostSyncStat()
192 {
193 syncTimes_++;
194 int ret = HiSysEventWrite(
195 MEDIA_LIBRARY,
196 "MEDIALIB_SYNC_STAT",
197 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
198 "TIMES", syncTimes_);
199 if (ret != 0) {
200 MEDIA_ERR_LOG("PostSyncStat ret:%{public}d", ret);
201 }
202 }
203
PostAgingStat(const VariantMap & stat)204 void PostEventUtils::PostAgingStat(const VariantMap &stat)
205 {
206 recycleTimes_++;
207 int ret = HiSysEventWrite(
208 MEDIA_LIBRARY,
209 "MEDIALIB_AGING_STAT",
210 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
211 "TIMES", recycleTimes_,
212 "COUNT", GetIntValue(KEY_COUNT, stat));
213 if (ret != 0) {
214 MEDIA_ERR_LOG("PostAgingStat error:%{public}d", ret);
215 }
216 }
217
PostMscFirstVisitStat(const VariantMap & stat)218 void PostEventUtils::PostMscFirstVisitStat(const VariantMap &stat)
219 {
220 string photoId = GetStringValue(KEY_PHOTO_ID, stat);
221 int64_t timeInterval = GetInt64Value(KEY_TIME_INTERVAL, stat);
222 int ret = HiSysEventWrite(
223 MEDIA_LIBRARY,
224 "MEDIALIB_MSC_FIRST_VISIT_STAT",
225 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
226 KEY_PHOTO_ID, photoId,
227 KEY_TIME_INTERVAL, timeInterval);
228 if (ret != 0) {
229 MEDIA_ERR_LOG("PostMscFirstVisitStat error:%{public}d", ret);
230 }
231 }
232
PostMscRequestPolicyStat(const VariantMap & stat)233 void PostEventUtils::PostMscRequestPolicyStat(const VariantMap &stat)
234 {
235 string callingPackage = GetStringValue(KEY_CALLING_PACKAGE, stat);
236 int32_t highQualityCount = GetIntValue(KEY_HIGH_QUALITY_COUNT, stat);
237 int32_t balanceQualityCount = GetIntValue(KEY_BALANCE_QUALITY_COUNT, stat);
238 int32_t emergencyQualityCount = GetIntValue(KEY_EMERGENCY_QUALITY_COUNT, stat);
239 int ret = HiSysEventWrite(
240 MEDIA_LIBRARY,
241 "MEDIALIB_MSC_REQUST_POLICY_STAT",
242 HiviewDFX::HiSysEvent::EventType::STATISTIC,
243 KEY_CALLING_PACKAGE, callingPackage,
244 KEY_HIGH_QUALITY_COUNT, highQualityCount,
245 KEY_BALANCE_QUALITY_COUNT, balanceQualityCount,
246 KEY_EMERGENCY_QUALITY_COUNT, emergencyQualityCount);
247 if (ret != 0) {
248 MEDIA_ERR_LOG("PostMscRequestPolicyStat error:%{public}d", ret);
249 }
250 }
251
PostMscTriggerRatioStat(const VariantMap & stat)252 void PostEventUtils::PostMscTriggerRatioStat(const VariantMap &stat)
253 {
254 int32_t thirdPartCount = GetIntValue(KEY_THIRD_PART_COUNT, stat);
255 int32_t autoCount = GetIntValue(KEY_AUTO_COUNT, stat);
256 int ret = HiSysEventWrite(
257 MEDIA_LIBRARY,
258 "MEDIALIB_MSC_TRIGGER_RATIO_STAT",
259 HiviewDFX::HiSysEvent::EventType::STATISTIC,
260 KEY_THIRD_PART_COUNT, thirdPartCount,
261 KEY_AUTO_COUNT, autoCount);
262 if (ret != 0) {
263 MEDIA_ERR_LOG("PostMscTriggerRatioStat error:%{public}d", ret);
264 }
265 }
266
PostMscTotalTimeCostStat(const VariantMap & stat)267 void PostEventUtils::PostMscTotalTimeCostStat(const VariantMap &stat)
268 {
269 string photoId = GetStringValue(KEY_PHOTO_ID, stat);
270 int64_t totalTimeCost = GetInt64Value(KEY_TOTAL_TIME_COST, stat);
271 int32_t mediaType = GetIntValue(KEY_MEDIA_TYPE, stat);
272 int ret = HiSysEventWrite(
273 MEDIA_LIBRARY,
274 "MEDIALIB_MSC_TOTAL_TIME_STAT",
275 HiviewDFX::HiSysEvent::EventType::STATISTIC,
276 KEY_PHOTO_ID, photoId,
277 KEY_TOTAL_TIME_COST, totalTimeCost,
278 KEY_MEDIA_TYPE, mediaType);
279 if (ret != 0) {
280 MEDIA_ERR_LOG("PostMscTotalTimeCostStat error:%{public}d", ret);
281 }
282 }
283
PostMscResultStat(const VariantMap & stat)284 void PostEventUtils::PostMscResultStat(const VariantMap &stat)
285 {
286 string photoId = GetStringValue(KEY_PHOTO_ID, stat);
287 int32_t result = GetIntValue(KEY_RESULT, stat);
288 int32_t mediaType = GetIntValue(KEY_MEDIA_TYPE, stat);
289 int ret = HiSysEventWrite(
290 MEDIA_LIBRARY,
291 "MEDIALIB_MSC_RESULT_STAT",
292 HiviewDFX::HiSysEvent::EventType::STATISTIC,
293 KEY_PHOTO_ID, photoId,
294 KEY_RESULT, result,
295 KEY_MEDIA_TYPE, mediaType);
296 if (ret != 0) {
297 MEDIA_ERR_LOG("PostMscResultStat error:%{public}d", ret);
298 }
299 }
300
PostDatabaseCorruption(const VariantMap & errMap)301 void PostEventUtils::PostDatabaseCorruption(const VariantMap &errMap)
302 {
303 string date = GetStringValue(KEY_DB_CORRUPT, errMap);
304 MEDIA_ERR_LOG("ReportDatabaseCorruption periodTime:%{public}s", date.c_str());
305 int ret = HiSysEventWrite(
306 MEDIA_LIBRARY,
307 "DATABASE_CORRUPTION_ERROR",
308 HiviewDFX::HiSysEvent::EventType::FAULT,
309 "DATE", date);
310 if (ret != 0) {
311 MEDIA_ERR_LOG("ReportDatabaseCorruption error:%{public}d", ret);
312 }
313 }
314
PostErrorProcess(const uint32_t & errType,const VariantMap & error)315 void PostEventUtils::PostErrorProcess(const uint32_t &errType, const VariantMap &error)
316 {
317 switch (errType) {
318 case ErrType::FILE_OPT_ERR:
319 case ErrType::DB_OPT_ERR:
320 case ErrType::DB_UPGRADE_ERR:
321 break;
322 case ErrType::DB_CORRUPT_ERR:
323 PostDatabaseCorruption(error);
324 break;
325 case ErrType::RECOVERY_ERR:
326 PostRecoveryOptError(error);
327 break;
328 default:
329 PostFileOptError(error);
330 PostDbOptError(error);
331 PostDbUpgradeError(error);
332 break;
333 }
334 }
335
PostCloudEnhanceStat(const VariantMap & stat)336 void PostEventUtils::PostCloudEnhanceStat(const VariantMap &stat)
337 {
338 std::string photoId = GetStringValue(KEY_PHOTO_ID, stat);
339 std::string completeType = GetStringValue(KEY_CLOUD_ENHANCEMENT_COMPLETE_TYPE, stat);
340 int64_t totalTimeCost = GetInt64Value(KEY_TOTAL_TIME_COST, stat);
341 int32_t finishType = GetIntValue(KEY_CLOUD_ENHANCEMENT_FINISH_TYPE, stat);
342 int ret = HiSysEventWrite(
343 MEDIA_LIBRARY,
344 "MEDIALIB_CLOUDENHANCEMENT_STAT",
345 HiviewDFX::HiSysEvent::EventType::STATISTIC,
346 KEY_PHOTO_ID, photoId,
347 KEY_TOTAL_TIME_COST, totalTimeCost,
348 KEY_CLOUD_ENHANCEMENT_COMPLETE_TYPE, completeType,
349 KEY_CLOUD_ENHANCEMENT_FINISH_TYPE, finishType);
350 if (ret != 0) {
351 MEDIA_ERR_LOG("PostCloudEnhanceStat:%{public}d", ret);
352 }
353 }
354
CreateCloudDownloadSyncStat(std::string & syncId)355 void PostEventUtils::CreateCloudDownloadSyncStat(std::string& syncId)
356 {
357 std::lock_guard<std::mutex> lock(cloudDownloadSyncStatMutex_);
358 cloudDownloadSyncStat_.clear();
359 user_alubm_count_.clear();
360 analysis_alunm_count_.clear();
361 currentSyncId_ = syncId;
362 MEDIA_INFO_LOG("currentSyncId is: %{public}s,", currentSyncId_.c_str());
363 }
364
UpdateCloudDownloadSyncStat(VariantMap & syncStat)365 void PostEventUtils::UpdateCloudDownloadSyncStat(VariantMap &syncStat)
366 {
367 static const std::set<std::string> KEY_SET = {
368 KEY_START_DOWNLOAD_TIME, KEY_END_DOWNLOAD_TIME, KEY_DOWNLOAD_TYPE, KEY_TOTAL_PHOTO_COUNT};
369 std::lock_guard<std::mutex> lock(cloudDownloadSyncStatMutex_);
370 for (const auto &[key, value] : syncStat) {
371 if (key == KEY_REFRESH_ANALYSIS_ALBUM_TOTAL_COUNT) {
372 analysis_alunm_count_.push_back(get<int32_t>(value));
373 } else if (key == KEY_REFRESH_USER_AND_SOURCE_ALBUM_TOTAL_COUNT) {
374 user_alubm_count_.push_back(get<int32_t>(value));
375 } else if (KEY_SET.count(key) > 0 || cloudDownloadSyncStat_.count(key) == 0) {
376 cloudDownloadSyncStat_[key] = value;
377 } else {
378 cloudDownloadSyncStat_[key] = get<int32_t>(cloudDownloadSyncStat_[key]) + get<int32_t>(value);
379 }
380 }
381 }
382
GetSyncEventStat(const VariantMap & stat)383 SyncEventStat PostEventUtils::GetSyncEventStat(const VariantMap &stat)
384 {
385 SyncEventStat syncEventStat;
386 syncEventStat.startDownloadTime = GetInt64Value(KEY_START_DOWNLOAD_TIME, stat);
387 syncEventStat.endDownloadTime = GetInt64Value(KEY_END_DOWNLOAD_TIME, stat);
388 syncEventStat.downloadType = GetIntValue(KEY_DOWNLOAD_TYPE, stat);
389 syncEventStat.totalPhotoCount = GetIntValue(KEY_TOTAL_PHOTO_COUNT, stat);
390
391 syncEventStat.totalAlbumNum = GetIntValue(KEY_TOTAL_ALBUM_NUM, stat);
392 syncEventStat.addAlbumNum = GetIntValue(KEY_ADD_ALBUM_NUM, stat);
393 syncEventStat.updateAlbumNum = GetIntValue(KEY_UPDATE_ALBUM_NUM, stat);
394 syncEventStat.deleteAlbumNum = GetIntValue(KEY_DELETE_ALBUM_NUM, stat);
395
396 syncEventStat.totalAssetNum = GetIntValue(KEY_TOTAL_ASSET_NUM, stat);
397 syncEventStat.addAssetNum = GetIntValue(KEY_ADD_ASSET_NUM, stat);
398 syncEventStat.updateAssetNum = GetIntValue(KEY_UPDATE_ASSET_NUM, stat);
399 syncEventStat.deleteAssetNum = GetIntValue(KEY_DELETE_ASSET_NUM, stat);
400
401 syncEventStat.avgRefreshImageVideoAlbumTime = GetIntValue(KEY_REFRESH_IMAGEVIDEO_ALBUM_TOTAL_TIME, stat) /
402 std::max(GetIntValue(KEY_REFRESH_IMAGEVIDEO_ALBUM_TOTAL_COUNT, stat), 1);
403
404 std::set<int32_t> user_set(user_alubm_count_.begin(), user_alubm_count_.end());
405 syncEventStat.refreshUserAndSourceAlbumCount = static_cast<int32_t>(user_set.size());
406 syncEventStat.avgRefreshUserAndSourceAlbumTime =
407 GetIntValue(KEY_REFRESH_USER_AND_SOURCE_ALBUM_TOTAL_TIME, stat) /
408 std::max(static_cast<int32_t>(user_alubm_count_.size()), 1);
409
410 std::set<int32_t> analysis_set(analysis_alunm_count_.begin(), analysis_alunm_count_.end());
411 syncEventStat.refreshAnalysisAlbumCount = static_cast<int32_t>(analysis_set.size());
412 syncEventStat.avgRefreshAnalysisAlbumTime = GetIntValue(KEY_REFRESH_ANALYSIS_ALBUM_TOTAL_TIME, stat) /
413 std::max(static_cast<int32_t>(analysis_alunm_count_.size()), 1);
414 return syncEventStat;
415 }
416
PostCloudDownloadSyncStat(std::string & syncId)417 void PostEventUtils::PostCloudDownloadSyncStat(std::string& syncId)
418 {
419 if (syncId != currentSyncId_) {
420 MEDIA_ERR_LOG("Invaild syncid! syncid is %{public}s and currentSyncId is %{public}s.",
421 syncId.c_str(),
422 currentSyncId_.c_str());
423 return;
424 }
425 std::unique_lock<std::mutex> lock(cloudDownloadSyncStatMutex_);
426 VariantMap stat;
427 stat.swap(cloudDownloadSyncStat_);
428 lock.unlock();
429 SyncEventStat syncEventStat = PostEventUtils::GetSyncEventStat(stat);
430 if (syncEventStat.totalAlbumNum == 0 && syncEventStat.totalAssetNum == 0 &&
431 syncEventStat.avgRefreshImageVideoAlbumTime == 0 && syncEventStat.avgRefreshUserAndSourceAlbumTime == 0 &&
432 syncEventStat.avgRefreshAnalysisAlbumTime == 0) {
433 return;
434 }
435 int ret = HiSysEventWrite(
436 MEDIA_LIBRARY,
437 "MEDIALIB_CLOUD_SYNC_STAT",
438 HiviewDFX::HiSysEvent::EventType::STATISTIC,
439 KEY_START_DOWNLOAD_TIME, syncEventStat.startDownloadTime,
440 KEY_END_DOWNLOAD_TIME, syncEventStat.endDownloadTime,
441 KEY_DOWNLOAD_TYPE, syncEventStat.downloadType,
442 KEY_TOTAL_PHOTO_COUNT, syncEventStat.totalPhotoCount,
443 KEY_TOTAL_ALBUM_NUM, syncEventStat.totalAlbumNum,
444 KEY_ADD_ALBUM_NUM, syncEventStat.addAlbumNum,
445 KEY_UPDATE_ALBUM_NUM, syncEventStat.updateAlbumNum,
446 KEY_DELETE_ALBUM_NUM, syncEventStat.deleteAlbumNum,
447 KEY_TOTAL_ASSET_NUM, syncEventStat.totalAssetNum,
448 KEY_ADD_ASSET_NUM, syncEventStat.addAssetNum,
449 KEY_UPDATE_ASSET_NUM, syncEventStat.updateAssetNum,
450 KEY_DELETE_ASSET_NUM, syncEventStat.deleteAssetNum,
451 KEY_AVG_REFRESH_IMAGEVIDEO_ALBUM_TIME, syncEventStat.avgRefreshImageVideoAlbumTime,
452 KEY_REFRESH_USER_AND_SOURCE_ALBUM_COUNT, syncEventStat.refreshUserAndSourceAlbumCount,
453 KEY_AVG_REFRESH_USER_AND_SOURCE_ALBUM_TIME, syncEventStat.avgRefreshUserAndSourceAlbumTime,
454 KEY_REFRESH_ANALYSIS_ALBUM_COUNT, syncEventStat.refreshAnalysisAlbumCount,
455 KEY_AVG_REFRESH_ANALYSIS_ALBUM_TIME, syncEventStat.avgRefreshAnalysisAlbumTime);
456 if (ret != 0) {
457 MEDIA_ERR_LOG("PostCloudDownloadSyncStat:%{public}d", ret);
458 }
459 }
460
PostStatProcess(const uint32_t & statType,const VariantMap & stat)461 void PostEventUtils::PostStatProcess(const uint32_t &statType, const VariantMap &stat)
462 {
463 switch (statType) {
464 case StatType::THUMBNAIL_STAT:
465 case StatType::DB_UPGRADE_STAT:
466 case StatType::SYNC_STAT:
467 case StatType::AGING_STAT:
468 break;
469 case StatType::MSC_FIRST_VISIT_STAT:
470 PostMscFirstVisitStat(stat);
471 break;
472 case StatType::MSC_REQUEST_POLICY_STAT:
473 PostMscRequestPolicyStat(stat);
474 break;
475 case StatType::MSC_TRIGGER_RATIO_STAT:
476 PostMscTriggerRatioStat(stat);
477 break;
478 case StatType::MSC_TOTAL_TIME_COST_STAT:
479 PostMscTotalTimeCostStat(stat);
480 break;
481 case StatType::MSC_RESULT_STAT:
482 PostMscResultStat(stat);
483 break;
484 case StatType::CLOUD_ENHANCEMENT_GET_COUNT_STAT:
485 PostCloudEnhanceStat(stat);
486 break;
487 default:
488 PostThumbnailStat(stat);
489 PostDbUpgradeStat(stat);
490 PostSyncStat();
491 PostAgingStat(stat);
492 break;
493 }
494 }
495 } // namespace Media
496 } // namespace OHOS
497