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 <filesystem>
17 #include <sys/statfs.h>
18 #include <dirent.h>
19 #include <sys/stat.h>
20
21 #include "dps_event_report.h"
22 #include "hisysevent.h"
23 #include "dp_log.h"
24 #include "timer/steady_clock.h"
25 #include "ideferred_photo_processing_session.h"
26
27 namespace OHOS {
28 namespace CameraStandard {
29 namespace DeferredProcessing {
30 static constexpr char CAMERA_FWK_UE[] = "CAMERA_FWK_UE";
31 static constexpr double INVALID_QUOTA = -2.00;
ReportOperateImage(const std::string & imageId,int32_t userId,DPSEventInfo & dpsEventInfo)32 void DPSEventReport::ReportOperateImage(const std::string& imageId, int32_t userId, DPSEventInfo& dpsEventInfo)
33 {
34 DP_DEBUG_LOG("ReportOperateImage enter.");
35 UpdateEventInfo(dpsEventInfo);
36 HiSysEventWrite(
37 CAMERA_FWK_UE,
38 "DPS_IMAGE_OPERATE",
39 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
40 EVENT_KEY_IMAGEID, imageId,
41 EVENT_KEY_USERID, userId,
42 EVENT_KEY_DEFEVENTTYPE, dpsEventInfo.operatorStage,
43 EVENT_KEY_DISCARDABLE, dpsEventInfo.discardable,
44 EVENT_KEY_TRIGGERMODE, dpsEventInfo.triggerMode,
45 EVENT_KEY_HIGHJOBNUM, dpsEventInfo.highJobNum,
46 EVENT_KEY_NORMALJOBNUM, dpsEventInfo.normalJobNum,
47 EVENT_KEY_LOWJOBNUM, dpsEventInfo.lowJobNum,
48 EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_);
49 }
50
ReportImageProcessResult(const std::string & imageId,int32_t userId,uint64_t endTime)51 void DPSEventReport::ReportImageProcessResult(const std::string& imageId, int32_t userId, uint64_t endTime)
52 {
53 DP_DEBUG_LOG("ReportImageProcessResult enter.");
54 DPSEventInfo dpsEventInfo = GetEventInfo(imageId, userId);
55 if (endTime > 0) {
56 dpsEventInfo.imageDoneTimeEndTime = endTime;
57 }
58 HiSysEventWrite(
59 CAMERA_FWK_UE,
60 "DPS_IMAGE_PROCESS_RESULT",
61 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
62 EVENT_KEY_IMAGEID, dpsEventInfo.imageId,
63 EVENT_KEY_USERID, dpsEventInfo.userId,
64 EVENT_KEY_SYNCHRONIZETIME, GetTotalTime(dpsEventInfo.synchronizeTimeBeginTime,
65 dpsEventInfo.synchronizeTimeEndTime),
66 EVENT_KEY_DISPATCHTIME, GetTotalTime(dpsEventInfo.dispatchTimeBeginTime, dpsEventInfo.dispatchTimeEndTime),
67 EVENT_KEY_PROCESSTIME, GetTotalTime(dpsEventInfo.processTimeBeginTime, dpsEventInfo.processTimeEndTime),
68 EVENT_KEY_IMAGEDONETIME, GetTotalTime(dpsEventInfo.imageDoneTimeBeginTime, dpsEventInfo.imageDoneTimeEndTime),
69 EVENT_KEY_RESTORETIME, GetTotalTime(dpsEventInfo.restoreTimeBeginTime, dpsEventInfo.restoreTimeEndTime),
70 EVENT_KEY_REMOVETIME, GetTotalTime(dpsEventInfo.removeTimeBeginTime, dpsEventInfo.removeTimeEndTime),
71 EVENT_KEY_TRAILINGTIME, GetTotalTime(dpsEventInfo.trailingTimeBeginTime, dpsEventInfo.trailingTimeEndTime),
72 EVENT_KEY_PHOTOJOBTYPE, static_cast<int32_t>(dpsEventInfo.photoJobType),
73 EVENT_KEY_HIGHJOBNUM, dpsEventInfo.highJobNum,
74 EVENT_KEY_NORMALJOBNUM, dpsEventInfo.normalJobNum,
75 EVENT_KEY_LOWJOBNUM, dpsEventInfo.lowJobNum,
76 EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_,
77 EVENT_KEY_EXECUTIONMODE, dpsEventInfo.executionMode);
78 RemoveEventInfo(imageId, userId);
79 }
80
GetTotalTime(uint64_t beginTime,uint64_t endTime)81 int DPSEventReport::GetTotalTime (uint64_t beginTime, uint64_t endTime)
82 {
83 return beginTime < endTime ? endTime - beginTime : 0;
84 }
85
ReportImageModeChange(ExecutionMode executionMode)86 void DPSEventReport::ReportImageModeChange(ExecutionMode executionMode)
87 {
88 DP_DEBUG_LOG("ReportImageModeChange enter.");
89 HiSysEventWrite(
90 CAMERA_FWK_UE,
91 "DPS_IMAGE_MODE_CHANGE",
92 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
93 EVENT_KEY_EXCUTIONMODE, static_cast<int32_t>(executionMode),
94 EVENT_KEY_CHANGEREASON, static_cast<int32_t>(eventType_),
95 EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_);
96 }
97
ReportImageException(const std::string & imageId,int32_t userId)98 void DPSEventReport::ReportImageException(const std::string& imageId, int32_t userId)
99 {
100 DPSEventInfo dpsEventInfo = GetEventInfo(imageId, userId);
101 HiSysEventWrite(
102 CAMERA_FWK_UE,
103 "DPS_IMAGE_EXCEPTION",
104 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
105 EVENT_KEY_IMAGEID, dpsEventInfo.imageId,
106 EVENT_KEY_USERID, dpsEventInfo.userId,
107 EVENT_KEY_EXCEPTIONSOURCE, static_cast<int32_t>(dpsEventInfo.exceptionSource),
108 EVENT_KEY_EXCEPTIONCAUSE, static_cast<int32_t>(dpsEventInfo.exceptionCause),
109 EVENT_KEY_TEMPERATURELEVEL, temperatureLevel_);
110 }
111
ReportPartitionUsage()112 void DPSEventReport::ReportPartitionUsage()
113 {
114 DP_DEBUG_LOG("ReportPartitionUsage enter");
115 std::vector<std::string> filePath = { PATH };
116 uint64_t size = GetFolderSize(PATH);
117 std::vector<uint64_t> fileSize = { size };
118 double remainPartitionSize = 0.0;
119 GetDeviceValidSize(PATH, remainPartitionSize);
120
121 HiSysEventWrite(
122 HiviewDFX::HiSysEvent::Domain::FILEMANAGEMENT,
123 "USER_DATA_SIZE",
124 HiviewDFX::HiSysEvent::EventType::STATISTIC,
125 EVENT_KEY_COMPONENT_NAME,
126 COMPONENT_NAME,
127 EVENT_KEY_PARTITION_NAME,
128 PARTITION_NAME,
129 EVENT_KEY_REMAIN_PARTITION_SIZE,
130 remainPartitionSize,
131 EVENT_KEY_FILE_OR_FOLDER_PAT,
132 filePath,
133 EVENT_KEY_FILE_OR_FOLDER_SIZE,
134 fileSize);
135 }
136
SetEventInfo(const std::string & imageId,int32_t userId)137 void DPSEventReport::SetEventInfo(const std::string& imageId, int32_t userId)
138 {
139 std::unique_lock<std::recursive_mutex> lock(mutex_);
140 DPSEventInfo dpsEventInfo;
141 dpsEventInfo.imageId = imageId;
142 dpsEventInfo.userId = userId;
143 dpsEventInfo.triggerMode = TrigerMode::TRIGER_ACTIVE;
144 dpsEventInfo.operatorStage = static_cast<uint32_t>(IDeferredPhotoProcessingSessionIpcCode::COMMAND_ADD_IMAGE);
145 dpsEventInfo.synchronizeTimeBeginTime = 0;
146 dpsEventInfo.synchronizeTimeEndTime = 0;
147 dpsEventInfo.dispatchTimeBeginTime = 0;
148 dpsEventInfo.dispatchTimeEndTime = 0;
149 dpsEventInfo.processTimeBeginTime = 0;
150 dpsEventInfo.processTimeEndTime = 0;
151 dpsEventInfo.imageDoneTimeBeginTime = 0;
152 dpsEventInfo.imageDoneTimeEndTime = 0;
153 dpsEventInfo.restoreTimeBeginTime = 0;
154 dpsEventInfo.restoreTimeEndTime = 0;
155 dpsEventInfo.removeTimeBeginTime = 0;
156 dpsEventInfo.removeTimeEndTime = 0;
157 dpsEventInfo.trailingTimeBeginTime = 0;
158 dpsEventInfo.trailingTimeEndTime = 0;
159 dpsEventInfo.highJobNum = 0;
160 dpsEventInfo.normalJobNum = 0;
161 dpsEventInfo.lowJobNum = 0;
162 dpsEventInfo.temperatureLevel = 0;
163 dpsEventInfo.executionMode = ExecutionMode::DUMMY;
164 dpsEventInfo.photoJobType = PhotoJobType::BACKGROUND;
165 dpsEventInfo.changeReason = EventType::USER_INITIATED_EVENT;
166 dpsEventInfo.exceptionSource = ExceptionSource::HDI_EXCEPTION;
167 dpsEventInfo.exceptionCause = ExceptionCause::HDI_TIMEOUT;
168
169 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
170 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
171 (imageIdToEventInfoTemp->second)[imageId] = dpsEventInfo;
172 } else {
173 std::map<std::string, DPSEventInfo> imageIdToEventInfo;
174 imageIdToEventInfo[imageId] = dpsEventInfo;
175 userIdToImageIdEventInfo[userId] = imageIdToEventInfo;
176 }
177 }
178
SetEventInfo(DPSEventInfo & dpsEventInfo)179 void DPSEventReport::SetEventInfo(DPSEventInfo& dpsEventInfo)
180 {
181 std::unique_lock<std::recursive_mutex> lock(mutex_);
182 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(dpsEventInfo.userId);
183 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
184 (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId] = dpsEventInfo;
185 } else {
186 std::map<std::string, DPSEventInfo> imageIdToEventInfo;
187 imageIdToEventInfo[dpsEventInfo.imageId] = dpsEventInfo;
188 userIdToImageIdEventInfo[dpsEventInfo.userId] = imageIdToEventInfo;
189 }
190 }
191
UpdateEventInfo(DPSEventInfo & dpsEventInfo)192 void DPSEventReport::UpdateEventInfo(DPSEventInfo& dpsEventInfo)
193 {
194 std::unique_lock<std::recursive_mutex> lock(mutex_);
195 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(dpsEventInfo.userId);
196 if (imageIdToEventInfoTemp == userIdToImageIdEventInfo.end()) {
197 std::map<std::string, DPSEventInfo> imageIdToEventInfo;
198 imageIdToEventInfo[dpsEventInfo.imageId] = dpsEventInfo;
199 userIdToImageIdEventInfo[dpsEventInfo.userId] = imageIdToEventInfo;
200 return;
201 }
202 DPSEventInfo dpsEventInfoTemp = (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId];
203 UpdateDispatchTime(dpsEventInfo, dpsEventInfoTemp);
204 UpdateProcessTime(dpsEventInfo, dpsEventInfoTemp);
205 UpdateRestoreTime(dpsEventInfo, dpsEventInfoTemp);
206 UpdateImageDoneTime(dpsEventInfo, dpsEventInfoTemp);
207 UpdateRemoveTime(dpsEventInfo, dpsEventInfoTemp);
208 UpdateTrailingTime(dpsEventInfo, dpsEventInfoTemp);
209 UpdateSynchronizeTime(dpsEventInfo, dpsEventInfoTemp);
210 UpdateExecutionMode(dpsEventInfo, dpsEventInfoTemp);
211
212 (imageIdToEventInfoTemp->second)[dpsEventInfo.imageId] = dpsEventInfo;
213 }
214
SetTemperatureLevel(int temperatureLevel)215 void DPSEventReport::SetTemperatureLevel(int temperatureLevel)
216 {
217 temperatureLevel_ = temperatureLevel;
218 }
219
SetExecutionMode(ExecutionMode executionMode)220 void DPSEventReport::SetExecutionMode(ExecutionMode executionMode)
221 {
222 executionMode_ = executionMode;
223 }
224
SetEventType(EventType eventType)225 void DPSEventReport::SetEventType(EventType eventType)
226 {
227 eventType_ = eventType;
228 }
229
GetEventInfo(const std::string & imageId,int32_t userId)230 DPSEventInfo DPSEventReport::GetEventInfo(const std::string& imageId, int32_t userId)
231 {
232 std::unique_lock<std::recursive_mutex> lock(mutex_);
233 DPSEventInfo dpsEventInfo;
234 auto imageIdToEventInfo = userIdToImageIdEventInfo.find(userId);
235 if (imageIdToEventInfo != userIdToImageIdEventInfo.end()) {
236 std::map<std::string, DPSEventInfo>::iterator iter = (userIdToImageIdEventInfo[userId]).begin();
237 while (iter != (userIdToImageIdEventInfo[userId]).end()) {
238 auto eventInfo = iter->second;
239 if (eventInfo.imageId == imageId) {
240 return eventInfo;
241 }
242 ++iter;
243 }
244 }
245 return dpsEventInfo;
246 }
247
RemoveEventInfo(const std::string & imageId,int32_t userId)248 void DPSEventReport::RemoveEventInfo(const std::string& imageId, int32_t userId)
249 {
250 std::unique_lock<std::recursive_mutex> lock(mutex_);
251 DPSEventInfo dpsEventInfo;
252 auto imageIdToEventInfo = userIdToImageIdEventInfo.find(userId);
253 if (imageIdToEventInfo != userIdToImageIdEventInfo.end()) {
254 std::map<std::string, DPSEventInfo>::iterator iter = (userIdToImageIdEventInfo[userId]).begin();
255 while (iter != (userIdToImageIdEventInfo[userId]).end()) {
256 if ((iter->second).imageId == imageId) {
257 (imageIdToEventInfo->second).erase(imageId);
258 return;
259 }
260 ++iter;
261 }
262 }
263 return;
264 }
265
UpdateProcessDoneTime(const std::string & imageId,int32_t userId)266 void DPSEventReport::UpdateProcessDoneTime(const std::string& imageId, int32_t userId)
267 {
268 std::unique_lock<std::recursive_mutex> lock(mutex_);
269 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
270 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
271 uint64_t currentTime = SteadyClock::GetTimestampMilli();
272 (imageIdToEventInfoTemp->second)[imageId].imageDoneTimeBeginTime = currentTime;
273 (imageIdToEventInfoTemp->second)[imageId].processTimeEndTime = currentTime;
274 }
275 }
276
UpdateSynchronizeTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)277 void DPSEventReport::UpdateSynchronizeTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
278 {
279 if (dpsEventInfoSrc.synchronizeTimeEndTime > 0) {
280 dpsEventInfo.synchronizeTimeEndTime = dpsEventInfoSrc.synchronizeTimeEndTime;
281 }
282 if (dpsEventInfoSrc.synchronizeTimeBeginTime > 0) {
283 dpsEventInfo.synchronizeTimeBeginTime = dpsEventInfoSrc.synchronizeTimeBeginTime;
284 }
285 }
286
UpdateDispatchTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)287 void DPSEventReport::UpdateDispatchTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
288 {
289 if (dpsEventInfoSrc.dispatchTimeBeginTime > 0) {
290 dpsEventInfo.dispatchTimeBeginTime = dpsEventInfoSrc.dispatchTimeBeginTime;
291 }
292 if (dpsEventInfoSrc.dispatchTimeEndTime > 0) {
293 dpsEventInfo.dispatchTimeEndTime = dpsEventInfoSrc.dispatchTimeEndTime;
294 }
295 }
296
UpdateProcessTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)297 void DPSEventReport::UpdateProcessTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
298 {
299 if (dpsEventInfoSrc.processTimeBeginTime > 0) {
300 dpsEventInfo.processTimeBeginTime = dpsEventInfoSrc.processTimeBeginTime;
301 }
302 if (dpsEventInfoSrc.processTimeEndTime > 0) {
303 dpsEventInfo.processTimeEndTime = dpsEventInfoSrc.processTimeEndTime;
304 }
305 }
306
UpdateImageDoneTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)307 void DPSEventReport::UpdateImageDoneTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
308 {
309 if (dpsEventInfoSrc.imageDoneTimeBeginTime > 0) {
310 dpsEventInfo.imageDoneTimeBeginTime = dpsEventInfoSrc.imageDoneTimeBeginTime;
311 }
312 if (dpsEventInfoSrc.imageDoneTimeEndTime > 0) {
313 dpsEventInfo.imageDoneTimeEndTime = dpsEventInfoSrc.imageDoneTimeEndTime;
314 }
315 }
316
UpdateRestoreTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)317 void DPSEventReport::UpdateRestoreTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
318 {
319 if (dpsEventInfoSrc.restoreTimeBeginTime > 0) {
320 dpsEventInfo.restoreTimeBeginTime = dpsEventInfoSrc.restoreTimeBeginTime;
321 }
322 if (dpsEventInfoSrc.restoreTimeEndTime > 0) {
323 dpsEventInfo.restoreTimeEndTime = dpsEventInfoSrc.restoreTimeEndTime;
324 }
325 }
326
UpdateRemoveTime(const std::string & imageId,int32_t userId)327 void DPSEventReport::UpdateRemoveTime(const std::string& imageId, int32_t userId)
328 {
329 std::unique_lock<std::recursive_mutex> lock(mutex_);
330 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
331 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
332 uint64_t currentTime = SteadyClock::GetTimestampMilli();
333 (imageIdToEventInfoTemp->second)[imageId].removeTimeEndTime = currentTime;
334 ReportImageProcessResult(imageId, userId);
335 }
336 }
337
UpdateRemoveTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)338 void DPSEventReport::UpdateRemoveTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
339 {
340 if (dpsEventInfoSrc.removeTimeBeginTime > 0) {
341 dpsEventInfo.removeTimeBeginTime = dpsEventInfoSrc.removeTimeBeginTime;
342 }
343 if (dpsEventInfoSrc.removeTimeEndTime > 0) {
344 dpsEventInfo.removeTimeEndTime = dpsEventInfoSrc.removeTimeEndTime;
345 }
346 }
347
UpdateTrailingTime(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)348 void DPSEventReport::UpdateTrailingTime(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
349 {
350 if (dpsEventInfoSrc.trailingTimeBeginTime > 0) {
351 dpsEventInfo.trailingTimeBeginTime = dpsEventInfoSrc.trailingTimeBeginTime;
352 }
353 if (dpsEventInfoSrc.trailingTimeEndTime > 0) {
354 dpsEventInfo.trailingTimeEndTime = dpsEventInfoSrc.trailingTimeEndTime;
355 }
356 }
357
UpdateExecutionMode(const std::string & imageId,int32_t userId,ExecutionMode executionMode)358 void DPSEventReport::UpdateExecutionMode(const std::string& imageId, int32_t userId, ExecutionMode executionMode)
359 {
360 std::unique_lock<std::recursive_mutex> lock(mutex_);
361 auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
362 if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
363 (imageIdToEventInfoTemp->second)[imageId].executionMode = executionMode;
364 }
365 }
366
UpdateExecutionMode(DPSEventInfo & dpsEventInfo,DPSEventInfo & dpsEventInfoSrc)367 void DPSEventReport::UpdateExecutionMode(DPSEventInfo& dpsEventInfo, DPSEventInfo& dpsEventInfoSrc)
368 {
369 if (dpsEventInfoSrc.executionMode >= ExecutionMode::HIGH_PERFORMANCE
370 && dpsEventInfoSrc.executionMode < ExecutionMode::DUMMY) {
371 dpsEventInfo.executionMode = dpsEventInfoSrc.executionMode;
372 }
373 }
374
GetDeviceValidSize(const std::string & path,double & size)375 bool DPSEventReport::GetDeviceValidSize(const std::string& path, double& size)
376 {
377 struct statfs stat;
378 if (statfs(path.c_str(), &stat) != 0) {
379 size = INVALID_QUOTA;
380 return false;
381 }
382 /* change Byte size to M */
383 constexpr double units = 1024.0;
384 size = (static_cast<double>(stat.f_bfree) / units) * (static_cast<double>(stat.f_bsize) / units);
385 return true;
386 }
387
GetFolderSize(const std::string & path)388 uint64_t DPSEventReport::GetFolderSize(const std::string& path)
389 {
390 uint64_t totalSize = 0;
391 struct stat st;
392 if (stat(path.c_str(), &st) != 0) {
393 return totalSize;
394 }
395 if (S_ISDIR(st.st_mode)) {
396 DIR* dir = opendir(path.c_str());
397 DP_DEBUG_LOG("GetFolderSize path:%{public}s, ERROR:%{public}d", path.c_str(), errno);
398 if (!dir) {
399 return totalSize;
400 }
401 struct dirent* entry;
402 while ((entry = readdir(dir)) != nullptr) {
403 std::string filePath = path + "/" + entry->d_name;
404 if ((entry->d_type == DT_DIR) &&
405 (std::string(entry->d_name) != "." && std::string(entry->d_name) != "..")) {
406 totalSize += GetFolderSize(filePath);
407 } else if (stat(filePath.c_str(), &st) == 0) {
408 totalSize += st.st_size;
409 }
410 }
411 closedir(dir);
412 } else {
413 totalSize = st.st_size;
414 }
415 return totalSize;
416 }
417
418 } // namsespace DeferredProcessingService
419 } // namespace CameraStandard
420 } // namespace OHOS