1 /*
2 * Copyright (c) 2023-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
16 #include "dps_event_report.h"
17 #include "hisysevent.h"
18 #include "dp_log.h"
19 #include "steady_clock.h"
20
21 namespace OHOS {
22 namespace CameraStandard {
23 namespace DeferredProcessing {
24 static constexpr char CAMERA_FWK_UE[] = "CAMERA_FWK_UE";
ReportOperateImage(const std::string & imageId,int32_t userId,DPSEventInfo & dpsEventInfo)25 void DPSEventReport::ReportOperateImage(const std::string& imageId, int32_t userId, DPSEventInfo& dpsEventInfo)
26 {
27 DP_DEBUG_LOG("ReportOperateImage enter.");
28 UpdateEventInfo(dpsEventInfo);
29 HiSysEventWrite(
30 CAMERA_FWK_UE,
31 "DPS_IMAGE_OPERATE",
32 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
33 EVENT_KEY_IMAGEID, imageId,
34 EVENT_KEY_USERID, userId,
35 EVENT_KEY_DEFEVENTTYPE, dpsEventInfo.operatorStage,
36 EVENT_KEY_DISCARDABLE, dpsEventInfo.discardable,
37 EVENT_KEY_TRIGGERMODE, dpsEventInfo.triggerMode,
38 EVENT_KEY_HIGHJOBNUM, dpsEventInfo.highJobNum,
39 EVENT_KEY_NORMALJOBNUM, dpsEventInfo.normalJobNum,
40 EVENT_KEY_LOWJOBNUM, dpsEventInfo.lowJobNum,
41 EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_);
42 }
43
ReportImageProcessResult(const std::string & imageId,int32_t userId,uint64_t endTime)44 void DPSEventReport::ReportImageProcessResult(const std::string& imageId, int32_t userId, uint64_t endTime)
45 {
46 DP_DEBUG_LOG("ReportImageProcessResult enter.");
47 DPSEventInfo dpsEventInfo = GetEventInfo(imageId, userId);
48 if (endTime > 0) {
49 dpsEventInfo.imageDoneTimeEndTime = endTime;
50 }
51 HiSysEventWrite(
52 CAMERA_FWK_UE,
53 "DPS_IMAGE_PROCESS_RESULT",
54 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
55 EVENT_KEY_IMAGEID, dpsEventInfo.imageId,
56 EVENT_KEY_USERID, dpsEventInfo.userId,
57 EVENT_KEY_SYNCHRONIZETIME, GetTotalTime(dpsEventInfo.synchronizeTimeBeginTime,
58 dpsEventInfo.synchronizeTimeEndTime),
59 EVENT_KEY_DISPATCHTIME, GetTotalTime(dpsEventInfo.dispatchTimeBeginTime, dpsEventInfo.dispatchTimeEndTime),
60 EVENT_KEY_PROCESSTIME, GetTotalTime(dpsEventInfo.processTimeBeginTime, dpsEventInfo.processTimeEndTime),
61 EVENT_KEY_IMAGEDONETIME, GetTotalTime(dpsEventInfo.imageDoneTimeBeginTime, dpsEventInfo.imageDoneTimeEndTime),
62 EVENT_KEY_RESTORETIME, GetTotalTime(dpsEventInfo.restoreTimeBeginTime, dpsEventInfo.restoreTimeEndTime),
63 EVENT_KEY_REMOVETIME, GetTotalTime(dpsEventInfo.removeTimeBeginTime, dpsEventInfo.removeTimeEndTime),
64 EVENT_KEY_TRAILINGTIME, GetTotalTime(dpsEventInfo.trailingTimeBeginTime, dpsEventInfo.trailingTimeEndTime),
65 EVENT_KEY_PHOTOJOBTYPE, static_cast<int32_t>(dpsEventInfo.photoJobType),
66 EVENT_KEY_HIGHJOBNUM, dpsEventInfo.highJobNum,
67 EVENT_KEY_NORMALJOBNUM, dpsEventInfo.normalJobNum,
68 EVENT_KEY_LOWJOBNUM, dpsEventInfo.lowJobNum,
69 EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_,
70 EVENT_KEY_EXECUTIONMODE, dpsEventInfo.executionMode);
71 RemoveEventInfo(imageId, userId);
72 }
73
GetTotalTime(uint64_t beginTime,uint64_t endTime)74 int DPSEventReport::GetTotalTime (uint64_t beginTime, uint64_t endTime)
75 {
76 if (beginTime < endTime) {
77 return endTime - beginTime;
78 }
79 return 0;
80 }
81
ReportImageModeChange(ExecutionMode executionMode)82 void DPSEventReport::ReportImageModeChange(ExecutionMode executionMode)
83 {
84 DP_INFO_LOG("ReportImageModeChange enter.");
85 HiSysEventWrite(
86 CAMERA_FWK_UE,
87 "DPS_IMAGE_MODE_CHANGE",
88 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
89 EVENT_KEY_EXCUTIONMODE, static_cast<int32_t>(executionMode),
90 EVENT_KEY_CHANGEREASON, static_cast<int32_t>(eventType_),
91 EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_);
92 }
93
ReportImageException(const std::string & imageId,int32_t userId)94 void DPSEventReport::ReportImageException(const std::string& imageId, int32_t userId)
95 {
96 DPSEventInfo dpsEventInfo = GetEventInfo(imageId, userId);
97 HiSysEventWrite(
98 CAMERA_FWK_UE,
99 "DPS_IMAGE_EXCEPTION",
100 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
101 EVENT_KEY_IMAGEID, dpsEventInfo.imageId,
102 EVENT_KEY_USERID, dpsEventInfo.userId,
103 EVENT_KEY_EXCEPTIONSOURCE, static_cast<int32_t>(dpsEventInfo.exceptionSource),
104 EVENT_KEY_EXCEPTIONCAUSE, static_cast<int32_t>(dpsEventInfo.exceptionCause),
105 EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_);
106 }
107
SetEventInfo(const std::string & imageId,int32_t userId)108 void DPSEventReport::SetEventInfo(const std::string& imageId, int32_t userId)
109 {
110 std::unique_lock<std::recursive_mutex> lock(mutex_);
111 DPSEventInfo dpsEventInfo;
112 dpsEventInfo.imageId = imageId;
113 dpsEventInfo.userId = userId;
114 dpsEventInfo.triggerMode = TrigerMode::TRIGER_ACTIVE;
115 dpsEventInfo.operatorStage = static_cast<uint32_t>(DeferredProcessingServiceInterfaceCode::DPS_ADD_IMAGE);
116 dpsEventInfo.synchronizeTimeBeginTime = 0;
117 dpsEventInfo.synchronizeTimeEndTime = 0;
118 dpsEventInfo.dispatchTimeBeginTime = 0;
119 dpsEventInfo.dispatchTimeEndTime = 0;
120 dpsEventInfo.processTimeBeginTime = 0;
121 dpsEventInfo.processTimeEndTime = 0;
122 dpsEventInfo.imageDoneTimeBeginTime = 0;
123 dpsEventInfo.imageDoneTimeEndTime = 0;
124 dpsEventInfo.restoreTimeBeginTime = 0;
125 dpsEventInfo.restoreTimeEndTime = 0;
126 dpsEventInfo.removeTimeBeginTime = 0;
127 dpsEventInfo.removeTimeEndTime = 0;
128 dpsEventInfo.trailingTimeBeginTime = 0;
129 dpsEventInfo.trailingTimeEndTime = 0;
130 dpsEventInfo.highJobNum = 0;
131 dpsEventInfo.normalJobNum = 0;
132 dpsEventInfo.lowJobNum = 0;
133 dpsEventInfo.temperatureLevel = 0;
134 dpsEventInfo.executionMode = ExecutionMode::DUMMY;
135 dpsEventInfo.photoJobType = PhotoJobType::BACKGROUND;
136 dpsEventInfo.changeReason = EventType::USER_INITIATED_EVENT;
137 dpsEventInfo.exceptionSource = ExceptionSource::HDI_EXCEPTION;
138 dpsEventInfo.exceptionCause = ExceptionCause::HDI_TIMEOUT;
139
140 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
141 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
142 (imageIdToEventInfoTemp->second)[imageId] = dpsEventInfo;
143 } else {
144 std::map<std::string, DPSEventInfo> imageIdToEventInfo;
145 imageIdToEventInfo[imageId] = dpsEventInfo;
146 userIdToImageIdEventInfo[userId] = imageIdToEventInfo;
147 }
148 }
149
SetEventInfo(DPSEventInfo & dpsEventInfo)150 void DPSEventReport::SetEventInfo(DPSEventInfo& dpsEventInfo)
151 {
152 std::unique_lock<std::recursive_mutex> lock(mutex_);
153 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(dpsEventInfo.userId);
154 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
155 (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId] = dpsEventInfo;
156 } else {
157 std::map<std::string, DPSEventInfo> imageIdToEventInfo;
158 imageIdToEventInfo[dpsEventInfo.imageId] = dpsEventInfo;
159 userIdToImageIdEventInfo[dpsEventInfo.userId] = imageIdToEventInfo;
160 }
161 }
162
UpdateEventInfo(DPSEventInfo & dpsEventInfo)163 void DPSEventReport::UpdateEventInfo(DPSEventInfo& dpsEventInfo)
164 {
165 std::unique_lock<std::recursive_mutex> lock(mutex_);
166 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(dpsEventInfo.userId);
167 if (imageIdToEventInfoTemp == userIdToImageIdEventInfo.end()) {
168 std::map<std::string, DPSEventInfo> imageIdToEventInfo;
169 imageIdToEventInfo[dpsEventInfo.imageId] = dpsEventInfo;
170 userIdToImageIdEventInfo[dpsEventInfo.userId] = imageIdToEventInfo;
171 return;
172 }
173 DPSEventInfo dpsEventInfoTemp = (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId];
174 UpdateDispatchTime(dpsEventInfo, dpsEventInfoTemp);
175 UpdateProcessTime(dpsEventInfo, dpsEventInfoTemp);
176 UpdateRestoreTime(dpsEventInfo, dpsEventInfoTemp);
177 UpdateImageDoneTime(dpsEventInfo, dpsEventInfoTemp);
178 UpdateRemoveTime(dpsEventInfo, dpsEventInfoTemp);
179 UpdateTrailingTime(dpsEventInfo, dpsEventInfoTemp);
180 UpdateSynchronizeTime(dpsEventInfo, dpsEventInfoTemp);
181 UpdateExecutionMode(dpsEventInfo, dpsEventInfoTemp);
182
183 (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId] = dpsEventInfo;
184 }
185
SetTemperatureLevel(int temperatureLevel)186 void DPSEventReport::SetTemperatureLevel(int temperatureLevel)
187 {
188 temperatureLevel_ = temperatureLevel;
189 }
190
SetExecutionMode(ExecutionMode executionMode)191 void DPSEventReport::SetExecutionMode(ExecutionMode executionMode)
192 {
193 executionMode_ = executionMode;
194 }
195
SetEventType(EventType eventType)196 void DPSEventReport::SetEventType(EventType eventType)
197 {
198 eventType_ = eventType;
199 }
200
GetEventInfo(const std::string & imageId,int32_t userId)201 DPSEventInfo DPSEventReport::GetEventInfo(const std::string& imageId, int32_t userId)
202 {
203 std::unique_lock<std::recursive_mutex> lock(mutex_);
204 DPSEventInfo dpsEventInfo;
205 auto imageIdToEventInfo = userIdToImageIdEventInfo.find(userId);
206 if (imageIdToEventInfo != userIdToImageIdEventInfo.end()) {
207 std::map<std::string, DPSEventInfo>::iterator iter = (userIdToImageIdEventInfo[userId]).begin();
208 while (iter != (userIdToImageIdEventInfo[userId]).end()) {
209 auto eventInfo = iter->second;
210 if (eventInfo.imageId == imageId) {
211 return eventInfo;
212 }
213 ++iter;
214 }
215 }
216 return dpsEventInfo;
217 }
218
RemoveEventInfo(const std::string & imageId,int32_t userId)219 void DPSEventReport::RemoveEventInfo(const std::string& imageId, int32_t userId)
220 {
221 std::unique_lock<std::recursive_mutex> lock(mutex_);
222 DPSEventInfo dpsEventInfo;
223 auto imageIdToEventInfo = userIdToImageIdEventInfo.find(userId);
224 if (imageIdToEventInfo != userIdToImageIdEventInfo.end()) {
225 std::map<std::string, DPSEventInfo>::iterator iter = (userIdToImageIdEventInfo[userId]).begin();
226 while (iter != (userIdToImageIdEventInfo[userId]).end()) {
227 if ((iter->second).imageId == imageId) {
228 (imageIdToEventInfo->second).erase(imageId);
229 return;
230 }
231 ++iter;
232 }
233 }
234 return;
235 }
236
UpdateProcessDoneTime(const std::string & imageId,int32_t userId)237 void DPSEventReport::UpdateProcessDoneTime(const std::string& imageId, int32_t userId)
238 {
239 std::unique_lock<std::recursive_mutex> lock(mutex_);
240 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
241 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
242 uint64_t currentTime = SteadyClock::GetTimestampMilli();
243 (imageIdToEventInfoTemp->second)[imageId].imageDoneTimeBeginTime = currentTime;
244 (imageIdToEventInfoTemp->second)[imageId].processTimeEndTime = currentTime;
245 }
246 }
247
UpdateSynchronizeTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)248 void DPSEventReport::UpdateSynchronizeTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
249 {
250 if (dpsEventInfoSrc.synchronizeTimeEndTime > 0) {
251 dpsEventInfo.synchronizeTimeEndTime = dpsEventInfoSrc.synchronizeTimeEndTime;
252 }
253 if (dpsEventInfoSrc.synchronizeTimeBeginTime > 0) {
254 dpsEventInfo.synchronizeTimeBeginTime = dpsEventInfoSrc.synchronizeTimeBeginTime;
255 }
256 }
257
UpdateDispatchTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)258 void DPSEventReport::UpdateDispatchTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
259 {
260 if (dpsEventInfoSrc.dispatchTimeBeginTime > 0) {
261 dpsEventInfo.dispatchTimeBeginTime = dpsEventInfoSrc.dispatchTimeBeginTime;
262 }
263 if (dpsEventInfoSrc.dispatchTimeEndTime > 0) {
264 dpsEventInfo.dispatchTimeEndTime = dpsEventInfoSrc.dispatchTimeEndTime;
265 }
266 }
267
UpdateProcessTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)268 void DPSEventReport::UpdateProcessTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
269 {
270 if (dpsEventInfoSrc.processTimeBeginTime > 0) {
271 dpsEventInfo.processTimeBeginTime = dpsEventInfoSrc.processTimeBeginTime;
272 }
273 if (dpsEventInfoSrc.processTimeEndTime > 0) {
274 dpsEventInfo.processTimeEndTime = dpsEventInfoSrc.processTimeEndTime;
275 }
276 }
277
UpdateImageDoneTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)278 void DPSEventReport::UpdateImageDoneTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
279 {
280 if (dpsEventInfoSrc.imageDoneTimeBeginTime > 0) {
281 dpsEventInfo.imageDoneTimeBeginTime = dpsEventInfoSrc.imageDoneTimeBeginTime;
282 }
283 if (dpsEventInfoSrc.imageDoneTimeEndTime > 0) {
284 dpsEventInfo.imageDoneTimeEndTime = dpsEventInfoSrc.imageDoneTimeEndTime;
285 }
286 }
287
UpdateRestoreTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)288 void DPSEventReport::UpdateRestoreTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
289 {
290 if (dpsEventInfoSrc.restoreTimeBeginTime > 0) {
291 dpsEventInfo.restoreTimeBeginTime = dpsEventInfoSrc.restoreTimeBeginTime;
292 }
293 if (dpsEventInfoSrc.restoreTimeEndTime > 0) {
294 dpsEventInfo.restoreTimeEndTime = dpsEventInfoSrc.restoreTimeEndTime;
295 }
296 }
297
UpdateRemoveTime(const std::string & imageId,int32_t userId)298 void DPSEventReport::UpdateRemoveTime(const std::string& imageId, int32_t userId)
299 {
300 std::unique_lock<std::recursive_mutex> lock(mutex_);
301 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
302 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
303 uint64_t currentTime = SteadyClock::GetTimestampMilli();
304 (imageIdToEventInfoTemp->second)[imageId].removeTimeEndTime = currentTime;
305 ReportImageProcessResult(imageId, userId);
306 }
307 }
308
UpdateRemoveTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)309 void DPSEventReport::UpdateRemoveTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
310 {
311 if (dpsEventInfoSrc.removeTimeBeginTime > 0) {
312 dpsEventInfo.removeTimeBeginTime = dpsEventInfoSrc.removeTimeBeginTime;
313 }
314 if (dpsEventInfoSrc.removeTimeEndTime > 0) {
315 dpsEventInfo.removeTimeEndTime = dpsEventInfoSrc.removeTimeEndTime;
316 }
317 }
318
UpdateTrailingTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)319 void DPSEventReport::UpdateTrailingTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
320 {
321 if (dpsEventInfoSrc.trailingTimeBeginTime > 0) {
322 dpsEventInfo.trailingTimeBeginTime = dpsEventInfoSrc.trailingTimeBeginTime;
323 }
324 if (dpsEventInfoSrc.trailingTimeEndTime > 0) {
325 dpsEventInfo.trailingTimeEndTime = dpsEventInfoSrc.trailingTimeEndTime;
326 }
327 }
328
UpdateExecutionMode(const std::string & imageId,int32_t userId,ExecutionMode executionMode)329 void DPSEventReport::UpdateExecutionMode(const std::string& imageId, int32_t userId, ExecutionMode executionMode)
330 {
331 std::unique_lock<std::recursive_mutex> lock(mutex_);
332 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
333 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
334 (imageIdToEventInfoTemp->second)[imageId].executionMode = executionMode;
335 }
336 }
337
UpdateExecutionMode(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)338 void DPSEventReport::UpdateExecutionMode(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
339 {
340 if (dpsEventInfoSrc.executionMode >= ExecutionMode::HIGH_PERFORMANCE
341 && dpsEventInfoSrc.executionMode < ExecutionMode::DUMMY) {
342 dpsEventInfo.executionMode = dpsEventInfoSrc.executionMode;
343 }
344 }
345
346 } // namsespace DeferredProcessingService
347 } // namespace CameraStandard
348 } // namespace OHOS