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     RemoveEventInfo(imageId, userId);
71 }
72 
GetTotalTime(uint64_t beginTime,uint64_t endTime)73 int DPSEventReport::GetTotalTime (uint64_t beginTime, uint64_t endTime)
74 {
75     if (beginTime < endTime) {
76         return endTime - beginTime;
77     }
78     return 0;
79 }
80 
ReportImageModeChange(ExecutionMode executionMode)81 void DPSEventReport::ReportImageModeChange(ExecutionMode executionMode)
82 {
83     DP_INFO_LOG("ReportImageModeChange enter.");
84     HiSysEventWrite(
85         CAMERA_FWK_UE,
86         "DPS_IMAGE_MODE_CHANGE",
87         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
88         EVENT_KEY_EXCUTIONMODE, static_cast<int32_t>(executionMode),
89         EVENT_KEY_CHANGEREASON, static_cast<int32_t>(eventType_),
90         EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_);
91 }
92 
ReportImageException(const std::string & imageId,int32_t userId)93 void DPSEventReport::ReportImageException(const std::string& imageId, int32_t userId)
94 {
95     DPSEventInfo dpsEventInfo = GetEventInfo(imageId, userId);
96     HiSysEventWrite(
97         CAMERA_FWK_UE,
98         "DPS_IMAGE_EXCEPTION",
99         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
100         EVENT_KEY_IMAGEID, dpsEventInfo.imageId,
101         EVENT_KEY_USERID, dpsEventInfo.userId,
102         EVENT_KEY_EXCEPTIONSOURCE, static_cast<int32_t>(dpsEventInfo.exceptionSource),
103         EVENT_KEY_EXCEPTIONCAUSE, static_cast<int32_t>(dpsEventInfo.exceptionCause),
104         EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_);
105 }
106 
SetEventInfo(const std::string & imageId,int32_t userId)107 void DPSEventReport::SetEventInfo(const std::string& imageId, int32_t userId)
108 {
109     std::unique_lock<std::mutex> lock(mutex_);
110     DPSEventInfo dpsEventInfo;
111     dpsEventInfo.imageId = imageId;
112     dpsEventInfo.userId = userId;
113     dpsEventInfo.triggerMode = TrigerMode::TRIGER_ACTIVE;
114     dpsEventInfo.operatorStage = static_cast<uint32_t>(DeferredProcessingServiceInterfaceCode::DPS_ADD_IMAGE);
115     dpsEventInfo.synchronizeTimeBeginTime = 0;
116     dpsEventInfo.synchronizeTimeEndTime = 0;
117     dpsEventInfo.dispatchTimeBeginTime = 0;
118     dpsEventInfo.dispatchTimeEndTime = 0;
119     dpsEventInfo.processTimeBeginTime = 0;
120     dpsEventInfo.processTimeEndTime = 0;
121     dpsEventInfo.imageDoneTimeBeginTime = 0;
122     dpsEventInfo.imageDoneTimeEndTime = 0;
123     dpsEventInfo.restoreTimeBeginTime = 0;
124     dpsEventInfo.restoreTimeEndTime = 0;
125     dpsEventInfo.removeTimeBeginTime = 0;
126     dpsEventInfo.removeTimeEndTime = 0;
127     dpsEventInfo.trailingTimeBeginTime = 0;
128     dpsEventInfo.trailingTimeEndTime = 0;
129     dpsEventInfo.highJobNum = 0;
130     dpsEventInfo.normalJobNum = 0;
131     dpsEventInfo.lowJobNum = 0;
132     dpsEventInfo.temperatureLevel = 0;
133     dpsEventInfo.executionMode = ExecutionMode::DUMMY;
134     dpsEventInfo.photoJobType = PhotoJobType::BACKGROUND;
135     dpsEventInfo.changeReason = EventType::USER_INITIATED_EVENT;
136     dpsEventInfo.exceptionSource = ExceptionSource::HDI_EXCEPTION;
137     dpsEventInfo.exceptionCause = ExceptionCause::HDI_TIMEOUT;
138 
139     auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
140     if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
141         (imageIdToEventInfoTemp->second)[imageId] = dpsEventInfo;
142     } else {
143         std::map<std::string, DPSEventInfo> imageIdToEventInfo;
144         imageIdToEventInfo[imageId] = dpsEventInfo;
145         userIdToImageIdEventInfo[userId] = imageIdToEventInfo;
146     }
147 }
148 
SetEventInfo(DPSEventInfo & dpsEventInfo)149 void DPSEventReport::SetEventInfo(DPSEventInfo& dpsEventInfo)
150 {
151     std::unique_lock<std::mutex> lock(mutex_);
152     auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(dpsEventInfo.userId);
153     if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
154         (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId] = dpsEventInfo;
155     } else {
156         std::map<std::string, DPSEventInfo> imageIdToEventInfo;
157         imageIdToEventInfo[dpsEventInfo.imageId] = dpsEventInfo;
158         userIdToImageIdEventInfo[dpsEventInfo.userId] = imageIdToEventInfo;
159     }
160 }
161 
UpdateEventInfo(DPSEventInfo & dpsEventInfo)162 void DPSEventReport::UpdateEventInfo(DPSEventInfo& dpsEventInfo)
163 {
164     std::unique_lock<std::mutex> lock(mutex_);
165     auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(dpsEventInfo.userId);
166     if (imageIdToEventInfoTemp == userIdToImageIdEventInfo.end()) {
167         std::map<std::string, DPSEventInfo> imageIdToEventInfo;
168         imageIdToEventInfo[dpsEventInfo.imageId] = dpsEventInfo;
169         userIdToImageIdEventInfo[dpsEventInfo.userId] = imageIdToEventInfo;
170         return;
171     }
172     DPSEventInfo dpsEventInfoTemp = (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId];
173     UpdateDispatchTime(dpsEventInfo, dpsEventInfoTemp);
174     UpdateProcessTime(dpsEventInfo, dpsEventInfoTemp);
175     UpdateRestoreTime(dpsEventInfo, dpsEventInfoTemp);
176     UpdateImageDoneTime(dpsEventInfo, dpsEventInfoTemp);
177     UpdateRemoveTime(dpsEventInfo, dpsEventInfoTemp);
178     UpdateTrailingTime(dpsEventInfo, dpsEventInfoTemp);
179     UpdateSynchronizeTime(dpsEventInfo, dpsEventInfoTemp);
180 
181     (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId] = dpsEventInfo;
182 }
183 
SetTemperatureLevel(int temperatureLevel)184 void DPSEventReport::SetTemperatureLevel(int temperatureLevel)
185 {
186     temperatureLevel_ = temperatureLevel;
187 }
188 
SetExecutionMode(ExecutionMode executionMode)189 void DPSEventReport::SetExecutionMode(ExecutionMode executionMode)
190 {
191     executionMode_ = executionMode;
192 }
193 
SetEventType(EventType eventType)194 void DPSEventReport::SetEventType(EventType eventType)
195 {
196     eventType_ = eventType;
197 }
198 
GetEventInfo(const std::string & imageId,int32_t userId)199 DPSEventInfo DPSEventReport::GetEventInfo(const std::string& imageId, int32_t userId)
200 {
201     std::unique_lock<std::mutex> lock(mutex_);
202     DPSEventInfo dpsEventInfo;
203     auto imageIdToEventInfo = userIdToImageIdEventInfo.find(userId);
204     if (imageIdToEventInfo != userIdToImageIdEventInfo.end()) {
205         std::map<std::string, DPSEventInfo>::iterator iter = (userIdToImageIdEventInfo[userId]).begin();
206         while (iter != (userIdToImageIdEventInfo[userId]).end()) {
207             auto eventInfo = iter->second;
208             if (eventInfo.imageId == imageId) {
209                 return eventInfo;
210             }
211             ++iter;
212         }
213     }
214     return dpsEventInfo;
215 }
216 
RemoveEventInfo(const std::string & imageId,int32_t userId)217 void DPSEventReport::RemoveEventInfo(const std::string& imageId, int32_t userId)
218 {
219     std::unique_lock<std::mutex> lock(mutex_);
220     DPSEventInfo dpsEventInfo;
221     auto imageIdToEventInfo = userIdToImageIdEventInfo.find(userId);
222     if (imageIdToEventInfo != userIdToImageIdEventInfo.end()) {
223         std::map<std::string, DPSEventInfo>::iterator iter = (userIdToImageIdEventInfo[userId]).begin();
224         while (iter != (userIdToImageIdEventInfo[userId]).end()) {
225             if ((iter->second).imageId == imageId) {
226                 (imageIdToEventInfo->second).erase(imageId);
227                 return;
228             }
229             ++iter;
230         }
231     }
232     return;
233 }
234 
UpdateProcessDoneTime(const std::string & imageId,int32_t userId)235 void DPSEventReport::UpdateProcessDoneTime(const std::string& imageId, int32_t userId)
236 {
237     std::unique_lock<std::mutex> lock(mutex_);
238     auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
239     if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
240         uint64_t currentTime = SteadyClock::GetTimestampMilli();
241         (imageIdToEventInfoTemp->second)[imageId].imageDoneTimeBeginTime = currentTime;
242         (imageIdToEventInfoTemp->second)[imageId].processTimeEndTime = currentTime;
243     }
244 }
245 
UpdateSynchronizeTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)246 void DPSEventReport::UpdateSynchronizeTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
247 {
248     if (dpsEventInfoSrc.synchronizeTimeEndTime > 0) {
249         dpsEventInfo.synchronizeTimeEndTime = dpsEventInfoSrc.synchronizeTimeEndTime;
250     }
251     if (dpsEventInfoSrc.synchronizeTimeBeginTime > 0) {
252         dpsEventInfo.synchronizeTimeBeginTime = dpsEventInfoSrc.synchronizeTimeBeginTime;
253     }
254 }
255 
UpdateDispatchTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)256 void DPSEventReport::UpdateDispatchTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
257 {
258     if (dpsEventInfoSrc.dispatchTimeBeginTime > 0) {
259         dpsEventInfo.dispatchTimeBeginTime = dpsEventInfoSrc.dispatchTimeBeginTime;
260     }
261     if (dpsEventInfoSrc.dispatchTimeEndTime > 0) {
262         dpsEventInfo.dispatchTimeEndTime = dpsEventInfoSrc.dispatchTimeEndTime;
263     }
264 }
265 
UpdateProcessTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)266 void DPSEventReport::UpdateProcessTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
267 {
268     if (dpsEventInfoSrc.processTimeBeginTime > 0) {
269         dpsEventInfo.processTimeBeginTime = dpsEventInfoSrc.processTimeBeginTime;
270     }
271     if (dpsEventInfoSrc.processTimeEndTime > 0) {
272         dpsEventInfo.processTimeEndTime = dpsEventInfoSrc.processTimeEndTime;
273     }
274 }
275 
UpdateImageDoneTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)276 void DPSEventReport::UpdateImageDoneTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
277 {
278     if (dpsEventInfoSrc.imageDoneTimeBeginTime > 0) {
279         dpsEventInfo.imageDoneTimeBeginTime = dpsEventInfoSrc.imageDoneTimeBeginTime;
280     }
281     if (dpsEventInfoSrc.imageDoneTimeEndTime > 0) {
282         dpsEventInfo.imageDoneTimeEndTime = dpsEventInfoSrc.imageDoneTimeEndTime;
283     }
284 }
285 
UpdateRestoreTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)286 void DPSEventReport::UpdateRestoreTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
287 {
288     if (dpsEventInfoSrc.restoreTimeBeginTime > 0) {
289         dpsEventInfo.restoreTimeBeginTime = dpsEventInfoSrc.restoreTimeBeginTime;
290     }
291     if (dpsEventInfoSrc.restoreTimeEndTime > 0) {
292         dpsEventInfo.restoreTimeEndTime = dpsEventInfoSrc.restoreTimeEndTime;
293     }
294 }
295 
UpdateRemoveTime(const std::string & imageId,int32_t userId)296 void DPSEventReport::UpdateRemoveTime(const std::string& imageId, int32_t userId)
297 {
298     auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
299     if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
300         uint64_t currentTime = SteadyClock::GetTimestampMilli();
301         (imageIdToEventInfoTemp->second)[imageId].removeTimeEndTime = currentTime;
302         ReportImageProcessResult(imageId, userId);
303     }
304 }
305 
UpdateRemoveTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)306 void DPSEventReport::UpdateRemoveTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
307 {
308     if (dpsEventInfoSrc.removeTimeBeginTime > 0) {
309         dpsEventInfo.removeTimeBeginTime = dpsEventInfoSrc.removeTimeBeginTime;
310     }
311     if (dpsEventInfoSrc.removeTimeEndTime > 0) {
312         dpsEventInfo.removeTimeEndTime = dpsEventInfoSrc.removeTimeEndTime;
313     }
314 }
315 
UpdateTrailingTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)316 void DPSEventReport::UpdateTrailingTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
317 {
318     if (dpsEventInfoSrc.trailingTimeBeginTime > 0) {
319         dpsEventInfo.trailingTimeBeginTime = dpsEventInfoSrc.trailingTimeBeginTime;
320     }
321     if (dpsEventInfoSrc.trailingTimeEndTime > 0) {
322         dpsEventInfo.trailingTimeEndTime = dpsEventInfoSrc.trailingTimeEndTime;
323     }
324 }
325 } // namsespace DeferredProcessingService
326 } // namespace CameraStandard
327 } // namespace OHOS