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 "b_radar/radar_app_statistic.h"
17 #include "b_radar/radar_const_inner.h"
18 #include "filemgmt_libhilog.h"
19 #include "hisysevent.h"
20
21 namespace OHOS::FileManagement::Backup {
22
23 const std::unordered_map<std::string, FileType> FileTypeDef = {
24 {"txt", TXT}, {"log", TXT}, {"json", TXT}, {"xml", TXT}, {"db", TXT}, {"db-compare", TXT},
25 {"jpg", PIC}, {"jpeg", PIC}, {"png", PIC}, {"bmp", PIC}, {"gif", PIC}, {"svg", PIC}, {"webp", PIC}, {"tif", PIC},
26 {"raw", PIC},
27 {"wav", AUDIO}, {"flac", AUDIO}, {"wma", AUDIO}, {"acc", AUDIO}, {"mp3", AUDIO}, {"ogg", AUDIO}, {"opus", AUDIO},
28 {"mov", VEDIO}, {"wmv", VEDIO}, {"rm", VEDIO}, {"rmvb", VEDIO}, {"3gp", VEDIO}, {"m4v", VEDIO}, {"mkv", VEDIO},
29 {"rar", COMPRESS}, {"zip", COMPRESS}, {"7z", COMPRESS}, {"gz", COMPRESS}, {"iso", COMPRESS}, {"tar", COMPRESS},
30 {"exe", BIN}, {"doc", BIN}, {"docx", BIN}, {"xls", BIN}, {"xlsx", BIN}, {"ppt", BIN}, {"pdf", BIN}
31 };
32
ToJsonString()33 std::string FileStatList::ToJsonString()
34 {
35 std::string result = "[";
36 ItemInfo* list = GetListPtr();
37 uint32_t size = GetListSize();
38 for (uint32_t i = 0; i < size; i++) {
39 if (i != 0) {
40 result += ",";
41 }
42 result += "{\"count\":" + std::to_string(list[i].count) + ", \"size\":" + std::to_string(list[i].size) + "}";
43 }
44 result += "]";
45 return result;
46 }
47
GetIndexByType(std::string fileExtension)48 uint8_t FileTypeStat::GetIndexByType(std::string fileExtension)
49 {
50 auto it = FileTypeDef.find(fileExtension);
51 if (fileExtension.size() > 0 && it != FileTypeDef.end()) {
52 return static_cast<uint8_t>(it->second);
53 }
54 return static_cast<uint8_t>(FileType::OTHER);
55 }
56
UpdateStat(std::string extension,uint64_t size)57 void FileTypeStat::UpdateStat(std::string extension, uint64_t size)
58 {
59 uint8_t idx = GetIndexByType(extension);
60 typeInfoList_[idx].count++;
61 typeInfoList_[idx].size += size;
62 }
63
UpdateStat(uint64_t fileSize)64 void FileSizeStat::UpdateStat(uint64_t fileSize)
65 {
66 if (fileSize < ONE_MB) {
67 sizeInfoList_[TINY].count++;
68 sizeInfoList_[TINY].size += fileSize;
69 } else if (fileSize < TWO_MB) {
70 sizeInfoList_[SMALL].count++;
71 sizeInfoList_[SMALL].size += fileSize;
72 } else if (fileSize < TEN_MB) {
73 sizeInfoList_[MEDIUM].count++;
74 sizeInfoList_[MEDIUM].size += fileSize;
75 } else if (fileSize < HUNDRED_MB) {
76 sizeInfoList_[BIG].count++;
77 sizeInfoList_[BIG].size += fileSize;
78 } else if (fileSize < ONE_GB) {
79 sizeInfoList_[GREAT_BIG].count++;
80 sizeInfoList_[GREAT_BIG].size += fileSize;
81 } else {
82 sizeInfoList_[GIANT].count++;
83 sizeInfoList_[GIANT].size += fileSize;
84 }
85 }
86
ReportBackup(const std::string & func,int32_t errorCode,std::string errMsg)87 void RadarAppStatistic::ReportBackup(const std::string &func, int32_t errorCode, std::string errMsg)
88 {
89 HiSysEventWrite(
90 DOMAIN,
91 BACKUP_RESTORE_APP_STATISTIC,
92 OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
93 APP_CALLER, appCaller_,
94 ORG_PKG, DOMAIN_NAME,
95 FUNC, func,
96 CONCURRENT_ID, uniqId_,
97 BIZ_SCENE, static_cast<int32_t>(BizScene::BACKUP),
98 FILE_SIZE_DIST, fileSizeDist_.ToJsonString(),
99 FILE_TYPE_DIST, fileTypeDist_.ToJsonString(),
100 SMALL_FILE_COUNT, smallFileCount_,
101 SMALL_FILE_SIZE, smallFileSize_,
102 BIG_FILE_COUNT, bigFileCount_,
103 BIG_FILE_SIZE, bigFileSize_,
104 TAR_FILE_COUNT, tarFileCount_,
105 TAR_FILE_SIZE, tarFileSize_,
106 TAR_BOUND_SIZE, tarBoundSize_,
107 DIR_DEPTH, dirDepth_,
108 MANAGE_JSON_SIZE, manageJsonSize_,
109 EXTENSION_CONNECT_SPEND, extConnectSpend_,
110 ON_BACKUP_SPEND, onBackupSpend_.GetSpan(),
111 ON_BACKUPEX_SPEND, onBackupexSpend_.GetSpan(),
112 TAR_SPEND, tarSpend_,
113 HASH_SPEND, static_cast<uint32_t>(hashSpendUS_ / MS_TO_US),
114 SCAN_FILE_SPEND, scanFileSpend_.GetSpan(),
115 SEND_RATE_ZERO_SPAN, static_cast<uint32_t>(sendRateZeroSpendUS_ / MS_TO_US),
116 DO_BACKUP_SPEND, doBackupSpend_.GetSpan(),
117 ERROR_MSG, errMsg,
118 ERROR_CODE, errorCode,
119 BIZ_STAGE, DEFAULT_STAGE,
120 STAGE_RES, errorCode == 0 ? STAGE_RES_SUCCESS : STAGE_RES_FAIL);
121 }
122
ReportBackup(const std::string & func,BError errCode)123 void RadarAppStatistic::ReportBackup(const std::string &func, BError errCode)
124 {
125 RadarError err(MODULE_BACKUP, errCode);
126 ReportBackup(func, err.GenCode(), err.errMsg_);
127 }
128
ReportRestore(const std::string & func,int32_t errorCode,std::string errMsg)129 void RadarAppStatistic::ReportRestore(const std::string &func, int32_t errorCode, std::string errMsg)
130 {
131 HiSysEventWrite(
132 DOMAIN,
133 BACKUP_RESTORE_APP_STATISTIC,
134 OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
135 APP_CALLER, appCaller_,
136 ORG_PKG, DOMAIN_NAME,
137 FUNC, func,
138 CONCURRENT_ID, uniqId_,
139 BIZ_SCENE, static_cast<int32_t>(BizScene::RESTORE),
140 BIG_FILE_COUNT, bigFileCount_,
141 BIG_FILE_SIZE, bigFileSize_,
142 TAR_FILE_COUNT, tarFileCount_,
143 TAR_FILE_SIZE, tarFileSize_,
144 TAR_BOUND_SIZE, tarBoundSize_,
145 EXTENSION_CONNECT_SPEND, extConnectSpend_,
146 ON_RESTORE_SPEND, onRestoreSpend_.GetSpan(),
147 ON_RESTOREEX_SPEND, onRestoreexSpend_.GetSpan(),
148 UNTAR_SPEND, untarSpend_,
149 BIG_FILE_SPEND, bigFileSpend_,
150 DO_RESTORE_SPEND, doRestoreSpend_,
151 ERROR_MSG, errMsg,
152 ERROR_CODE, errorCode,
153 BIZ_STAGE, DEFAULT_STAGE,
154 STAGE_RES, errorCode == 0 ? STAGE_RES_SUCCESS : STAGE_RES_FAIL);
155 }
156
ReportRestore(const std::string & func,BError errCode)157 void RadarAppStatistic::ReportRestore(const std::string &func, BError errCode)
158 {
159 RadarError err(MODULE_RESTORE, errCode);
160 ReportRestore(func, err.GenCode(), err.errMsg_);
161 }
162
UpdateSendRateZeroSpend()163 void RadarAppStatistic::UpdateSendRateZeroSpend()
164 {
165 sendRateZeroSpendUS_ += TimeUtils::GetSpendUS(sendRateZeroStart_);
166 sendRateZeroStart_ = 0;
167 }
168
UpdateFileDist(std::string fileExtension,uint64_t fileSize)169 void RadarAppStatistic::UpdateFileDist(std::string fileExtension, uint64_t fileSize)
170 {
171 fileSizeDist_.UpdateStat(fileSize);
172 fileTypeDist_.UpdateStat(fileExtension, fileSize);
173 }
174
ReportError(const std::string & func,RadarError error)175 void RadarAppStatistic::ReportError(const std::string &func, RadarError error)
176 {
177 HiSysEventWrite(
178 DOMAIN,
179 BACKUP_RESTORE_APP_STATISTIC,
180 OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
181 APP_CALLER, appCaller_,
182 ORG_PKG, DOMAIN_NAME,
183 FUNC, func,
184 CONCURRENT_ID, uniqId_,
185 BIZ_SCENE, static_cast<int32_t>(bizScene_),
186 ERROR_MSG, error.errMsg_,
187 ERROR_CODE, error.GenCode(),
188 BIZ_STAGE, DEFAULT_STAGE,
189 STAGE_RES, error.error_ == 0 ? STAGE_RES_SUCCESS : STAGE_RES_FAIL);
190 }
191
ReportSA(const std::string & func,RadarError error)192 void RadarAppStatistic::ReportSA(const std::string &func, RadarError error)
193 {
194 HiSysEventWrite(
195 DOMAIN,
196 BACKUP_RESTORE_APP_STATISTIC,
197 OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
198 APP_CALLER, appCaller_,
199 ORG_PKG, DOMAIN_NAME,
200 FUNC, func,
201 CONCURRENT_ID, uniqId_,
202 BIZ_SCENE, static_cast<int32_t>(bizScene_),
203 DO_BACKUP_SPEND, doBackupSpend_.GetSpan(),
204 DO_RESTORE_SPEND, doRestoreSpend_,
205 ERROR_MSG, error.errMsg_,
206 ERROR_CODE, error.GenCode(),
207 BIZ_STAGE, DEFAULT_STAGE,
208 STAGE_RES, error.error_ == 0 ? STAGE_RES_SUCCESS : STAGE_RES_FAIL);
209 }
210
211 } // namespace OHOS::FileManagement::Backup