1 /*
2 * Copyright (c) 2024 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 <mutex>
17 #include <cinttypes>
18 #include <unordered_map>
19 #include "bms_adapter.h"
20 #include "camera_report_uitls.h"
21
22 #include "camera_log.h"
23 #include "hisysevent.h"
24 #include "ipc_skeleton.h"
25 #include "base/timer/steady_clock.h"
26
27 namespace OHOS {
28 namespace CameraStandard {
29 using namespace std;
30
31 constexpr const char* DFX_BEHAVIOR_MAP[] = {
32 "ZoomRatio", // DFX_UB_SET_ZOOMRATIO
33 "ZoomRatio", // DFX_UB_SET_SMOOTHZOOM
34 "VideoStabilizationMode", // DFX_UB_SET_VIDEOSTABILIZATIONMODE
35 "FilterType", // DFX_UB_SET_FILTER
36 "PortraitEffect", // DFX_UB_SET_PORTRAITEFFECT
37 "BeautyValue", // DFX_UB_SET_BEAUTY_AUTOVALUE
38 "SkinSmooth", // DFX_UB_SET_BEAUTY_SKINSMOOTH
39 "FaceSlender", // DFX_UB_SET_BEAUTY_FACESLENDER
40 "SkinTone", // DFX_UB_SET_BEAUTY_SKINTONE
41 "FocusMode", // DFX_UB_SET_FOCUSMODE
42 "FocusPoint", // DFX_UB_SET_FOCUSPOINT
43 "ExposureMode", // DFX_UB_SET_EXPOSUREMODE
44 "ExposureBias", // DFX_UB_SET_EXPOSUREBIAS
45 "MeteringPoint", // DFX_UB_SET_METERINGPOINT
46 "FlashMode", // DFX_UB_SET_FLASHMODE
47 "FrameRateRange", // DFX_UB_SET_FRAMERATERANGE
48 "MuteCamera", // DFX_UB_MUTE_CAMERA
49 "SetQualityPrioritization" // DFX_UB_SET_QUALITY_PRIORITIZATION
50 };
51
GetBehaviorImagingKey(DFX_UB_NAME behavior)52 const char* GetBehaviorImagingKey(DFX_UB_NAME behavior)
53 {
54 if (behavior < 0 || behavior >= sizeof(DFX_BEHAVIOR_MAP) / sizeof(DFX_BEHAVIOR_MAP[0])) {
55 return nullptr;
56 }
57 return DFX_BEHAVIOR_MAP[behavior];
58 };
59
SetOpenCamPerfPreInfo(const string & cameraId,CallerInfo caller)60 void CameraReportUtils::SetOpenCamPerfPreInfo(const string& cameraId, CallerInfo caller)
61 {
62 MEDIA_DEBUG_LOG("SetOpenCamPerfPreInfo");
63 unique_lock<mutex> lock(mutex_);
64 {
65 if (IsCallerChanged(caller_, caller)) {
66 MEDIA_DEBUG_LOG("SetOpenCamPerfPreInfo caller changed");
67 isModeChanging_ = false;
68 }
69 openCamPerfStartTime_ = DeferredProcessing::SteadyClock::GetTimestampMilli();
70 isPrelaunching_ = true;
71 cameraId_ = cameraId;
72 caller_ = caller;
73 }
74 }
75
SetOpenCamPerfStartInfo(const string & cameraId,CallerInfo caller)76 void CameraReportUtils::SetOpenCamPerfStartInfo(const string& cameraId, CallerInfo caller)
77 {
78 MEDIA_DEBUG_LOG("SetOpenCamPerfStartInfo");
79 unique_lock<mutex> lock(mutex_);
80 {
81 if (IsCallerChanged(caller_, caller)) {
82 MEDIA_DEBUG_LOG("SetOpenCamPerfStartInfo caller changed");
83 isModeChanging_ = false;
84 }
85 if (!isPrelaunching_) {
86 openCamPerfStartTime_ = DeferredProcessing::SteadyClock::GetTimestampMilli();
87 isOpening_ = true;
88 MEDIA_DEBUG_LOG("SetOpenCamPerfStartInfo update start time");
89 }
90 preCameraId_ = cameraId_;
91 cameraId_ = cameraId;
92 caller_ = caller;
93 }
94 }
95
SetStreamInfo(const std::list<sptr<HStreamCommon>> & allStreams)96 void CameraReportUtils::SetStreamInfo(const std::list<sptr<HStreamCommon>>& allStreams)
97 {
98 unique_lock<mutex> lock(mutex_);
99 stringstream ss;
100 bool isFirst = true;
101 for (auto& curStream : allStreams) {
102 CHECK_EXECUTE(!isFirst, ss << ",");
103 isFirst = false;
104 if (curStream->GetStreamType() == StreamType::REPEAT) {
105 ss << "\'RepeatStreamType:" <<
106 static_cast<int32_t>(CastStream<HStreamRepeat>(curStream)->GetRepeatStreamType()) <<
107 ",format:" << curStream->format_ << ",width:" << curStream->width_ << ",height:" <<
108 curStream->height_ << "\'";
109 } else if (curStream->GetStreamType() == StreamType::METADATA) {
110 ss << "\'MetadataStream, format:" << curStream->format_ << ",width:" << curStream->width_ <<
111 ",height:" << curStream->height_ << "\'";
112 } else if (curStream->GetStreamType() == StreamType::CAPTURE) {
113 ss << "\'CaptureStream, format:" << curStream->format_ << ",width:" << curStream->width_ <<
114 ",height:" << curStream->height_ << "\'";
115 } else if (curStream->GetStreamType() == StreamType::DEPTH) {
116 ss << "\'DepthStream, format:" << curStream->format_ << ",width:" << curStream->width_ <<
117 ",height:" << curStream->height_ << "\'";
118 }
119 }
120 streamInfo_ = ss.str();
121 }
122
SetOpenCamPerfEndInfo()123 void CameraReportUtils::SetOpenCamPerfEndInfo()
124 {
125 MEDIA_DEBUG_LOG("SetOpenCamPerfEndInfo");
126 unique_lock<mutex> lock(mutex_);
127 {
128 if (!isPrelaunching_ && !isOpening_) {
129 MEDIA_DEBUG_LOG("SetOpenCamPerfEndInfo not ready");
130 return;
131 }
132 if (isSwitching_) {
133 MEDIA_DEBUG_LOG("SetOpenCamPerfEndInfo cancel report");
134 isOpening_ = false;
135 isPrelaunching_ = false;
136 return;
137 }
138 openCamPerfEndTime_ = DeferredProcessing::SteadyClock::GetTimestampMilli();
139 string startType = isPrelaunching_ ? "preLaunch" : "open";
140 isOpening_ = false;
141 isPrelaunching_ = false;
142 ReportOpenCameraPerf(openCamPerfEndTime_ - openCamPerfStartTime_, startType);
143 }
144 }
145
ReportOpenCameraPerf(uint64_t costTime,const string & startType)146 void CameraReportUtils::ReportOpenCameraPerf(uint64_t costTime, const string& startType)
147 {
148 MEDIA_DEBUG_LOG("ReportOpenCameraPerf costTime: %{public}" PRIu64 "", costTime);
149 HiSysEventWrite(
150 HiviewDFX::HiSysEvent::Domain::CAMERA,
151 "PERFORMANCE_START",
152 HiviewDFX::HiSysEvent::EventType::STATISTIC,
153 "CALLER_PID", caller_.pid,
154 "CALLER_UID", caller_.uid,
155 "CALLER_TOKENID", caller_.tokenID,
156 "CALLER_BUNDLE_NAME", caller_.bundleName,
157 "COST_TIME", costTime,
158 "CUR_CAMERA_ID", cameraId_,
159 "START_TYPE", startType,
160 "CUR_MODE", curMode_,
161 "MSG", streamInfo_);
162 }
163
SetModeChangePerfStartInfo(int32_t preMode,CallerInfo caller)164 void CameraReportUtils::SetModeChangePerfStartInfo(int32_t preMode, CallerInfo caller)
165 {
166 MEDIA_DEBUG_LOG("SetModeChangePerfStartInfo");
167 unique_lock<mutex> lock(mutex_);
168 {
169 modeChangeStartTime_ = DeferredProcessing::SteadyClock::GetTimestampMilli();
170 isModeChanging_ = true;
171 preMode_ = preMode;
172 caller_ = caller;
173 ResetImagingValue();
174 }
175 }
176
updateModeChangePerfInfo(int32_t curMode,CallerInfo caller)177 void CameraReportUtils::updateModeChangePerfInfo(int32_t curMode, CallerInfo caller)
178 {
179 MEDIA_DEBUG_LOG("updateModeChangePerfInfo");
180 unique_lock<mutex> lock(mutex_);
181 {
182 if (IsCallerChanged(caller_, caller)) {
183 MEDIA_DEBUG_LOG("updateModeChangePerfInfo caller changed, cancle mode change report");
184 isModeChanging_ = false;
185 }
186 caller_ = caller;
187 curMode_ = curMode;
188 }
189 }
190
SetModeChangePerfEndInfo()191 void CameraReportUtils::SetModeChangePerfEndInfo()
192 {
193 MEDIA_DEBUG_LOG("SetModeChangePerfEndInfo");
194 unique_lock<mutex> lock(mutex_);
195 {
196 if (!isModeChanging_) {
197 MEDIA_DEBUG_LOG("SetModeChangePerfEndInfo cancel report");
198 return;
199 }
200 if (curMode_ == preMode_ || isSwitching_) {
201 MEDIA_DEBUG_LOG("SetModeChangePerfEndInfo mode not changed");
202 isModeChanging_ = false;
203 return;
204 }
205
206 modeChangeEndTime_ = DeferredProcessing::SteadyClock::GetTimestampMilli();
207 isModeChanging_ = false;
208 ReportModeChangePerf(modeChangeEndTime_ - modeChangeStartTime_);
209 }
210 }
211
ReportModeChangePerf(uint64_t costTime)212 void CameraReportUtils::ReportModeChangePerf(uint64_t costTime)
213 {
214 MEDIA_DEBUG_LOG("ReportModeChangePerf costTime: %{public}" PRIu64 "", costTime);
215 HiSysEventWrite(
216 HiviewDFX::HiSysEvent::Domain::CAMERA,
217 "PERFORMANCE_MODE_CHANGE",
218 HiviewDFX::HiSysEvent::EventType::STATISTIC,
219 "CALLER_PID", caller_.pid,
220 "CALLER_UID", caller_.uid,
221 "CALLER_TOKENID", caller_.tokenID,
222 "CALLER_BUNDLE_NAME", caller_.bundleName,
223 "COST_TIME", costTime,
224 "PRE_MODE", preMode_,
225 "CUR_MODE", curMode_,
226 "PRE_CAMERA_ID", preCameraId_,
227 "CUR_CAMERA_ID", cameraId_);
228 }
229
SetCapturePerfStartInfo(DfxCaptureInfo captureInfo)230 void CameraReportUtils::SetCapturePerfStartInfo(DfxCaptureInfo captureInfo)
231 {
232 MEDIA_DEBUG_LOG("SetCapturePerfStartInfo captureID: %{public}d", captureInfo.captureId);
233 captureInfo.captureStartTime = DeferredProcessing::SteadyClock::GetTimestampMilli();
234 unique_lock<mutex> lock(mutex_);
235 captureList_.insert(pair<int32_t, DfxCaptureInfo>(captureInfo.captureId, captureInfo));
236 }
237
SetCapturePerfEndInfo(int32_t captureId,bool isOfflinCapture,int32_t offlineOutputCnt)238 void CameraReportUtils::SetCapturePerfEndInfo(int32_t captureId, bool isOfflinCapture, int32_t offlineOutputCnt)
239 {
240 MEDIA_DEBUG_LOG("SetCapturePerfEndInfo start");
241 unique_lock<mutex> lock(mutex_);
242 {
243 map<int32_t, DfxCaptureInfo>::iterator iter = captureList_.find(captureId);
244 if (iter != captureList_.end()) {
245 MEDIA_DEBUG_LOG("SetCapturePerfEndInfo");
246 auto dfxCaptureInfo = iter->second;
247 dfxCaptureInfo.captureEndTime = DeferredProcessing::SteadyClock::GetTimestampMilli();
248 dfxCaptureInfo.isOfflinCapture = isOfflinCapture;
249 dfxCaptureInfo.offlineOutputCnt = static_cast<uint32_t>(offlineOutputCnt);
250 ReportCapturePerf(dfxCaptureInfo);
251 ReportImagingInfo(dfxCaptureInfo);
252 captureList_.erase(captureId);
253 }
254 }
255 }
256
ReportCapturePerf(DfxCaptureInfo captureInfo)257 void CameraReportUtils::ReportCapturePerf(DfxCaptureInfo captureInfo)
258 {
259 MEDIA_DEBUG_LOG("ReportCapturePerf captureInfo");
260 HiSysEventWrite(
261 HiviewDFX::HiSysEvent::Domain::CAMERA,
262 "PERFORMANCE_CAPTURE",
263 HiviewDFX::HiSysEvent::EventType::STATISTIC,
264 "CALLER_PID", captureInfo.caller.pid,
265 "CALLER_UID", captureInfo.caller.uid,
266 "CALLER_TOKENID", captureInfo.caller.tokenID,
267 "CALLER_BUNDLE_NAME", captureInfo.caller.bundleName,
268 "COST_TIME", captureInfo.captureEndTime - captureInfo.captureStartTime,
269 "CAPTURE_ID", captureInfo.captureId,
270 "CUR_MODE", curMode_,
271 "CUR_CAMERA_ID", cameraId_,
272 "IS_OFFLINE_CAPTURE", captureInfo.isOfflinCapture,
273 "CUR_OFFLINE_COUNT", captureInfo.offlineOutputCnt);
274 }
275
SetSwitchCamPerfStartInfo(CallerInfo caller)276 void CameraReportUtils::SetSwitchCamPerfStartInfo(CallerInfo caller)
277 {
278 MEDIA_DEBUG_LOG("SetSwitchCamPerfStartInfo");
279 unique_lock<mutex> lock(mutex_);
280 {
281 switchCamPerfStartTime_ = DeferredProcessing::SteadyClock::GetTimestampMilli();
282 isSwitching_ = true;
283 caller_ = caller;
284 }
285 }
286
SetSwitchCamPerfEndInfo()287 void CameraReportUtils::SetSwitchCamPerfEndInfo()
288 {
289 MEDIA_DEBUG_LOG("SetSwitchCamPerfEndInfo");
290 unique_lock<mutex> lock(mutex_);
291 {
292 if (!isSwitching_) {
293 MEDIA_DEBUG_LOG("SetSwitchCamPerfEndInfo cancel report");
294 return;
295 }
296
297 switchCamPerfEndTime_ = DeferredProcessing::SteadyClock::GetTimestampMilli();
298 isSwitching_ = false;
299 ReportSwitchCameraPerf(switchCamPerfEndTime_ - switchCamPerfStartTime_);
300 }
301 }
302
ReportSwitchCameraPerf(uint64_t costTime)303 void CameraReportUtils::ReportSwitchCameraPerf(uint64_t costTime)
304 {
305 MEDIA_DEBUG_LOG("ReportSwitchCameraPerf costTime: %{public}" PRIu64 "", costTime);
306 HiSysEventWrite(
307 HiviewDFX::HiSysEvent::Domain::CAMERA,
308 "PERFORMANCE_SWITCH_CAMERA",
309 HiviewDFX::HiSysEvent::EventType::STATISTIC,
310 "CALLER_PID", caller_.pid,
311 "CALLER_UID", caller_.uid,
312 "CALLER_TOKENID", caller_.tokenID,
313 "CALLER_BUNDLE_NAME", caller_.bundleName,
314 "COST_TIME", costTime,
315 "PRE_MODE", preMode_,
316 "CUR_MODE", curMode_,
317 "PRE_CAMERA_ID", preCameraId_,
318 "CUR_CAMERA_ID", cameraId_);
319 }
320
GetCallerInfo()321 CallerInfo CameraReportUtils::GetCallerInfo()
322 {
323 CallerInfo callerInfo;
324 callerInfo.pid = IPCSkeleton::GetCallingPid();
325 callerInfo.uid = IPCSkeleton::GetCallingUid();
326 callerInfo.tokenID = IPCSkeleton::GetCallingTokenID();
327 callerInfo.bundleName = BmsAdapter::GetInstance()->GetBundleName(callerInfo.uid);
328 MEDIA_DEBUG_LOG("GetCallerInfo pid:%{public}d uid:%{public}d", callerInfo.pid, callerInfo.uid);
329 return callerInfo;
330 }
331
IsCallerChanged(CallerInfo preCaller,CallerInfo curCaller)332 bool CameraReportUtils::IsCallerChanged(CallerInfo preCaller, CallerInfo curCaller)
333 {
334 if (preCaller.pid != curCaller.pid ||
335 preCaller.uid != curCaller.uid ||
336 preCaller.tokenID != curCaller.tokenID
337 ) {
338 return true;
339 }
340 return false;
341 }
342
ReportCameraError(string funcName,int32_t errCode,bool isHdiErr,CallerInfo callerInfo)343 void CameraReportUtils::ReportCameraError(string funcName,
344 int32_t errCode,
345 bool isHdiErr,
346 CallerInfo callerInfo)
347 {
348 string str = funcName;
349 if (isHdiErr) {
350 str += " faild, hdi errCode:" + to_string(errCode);
351 } else {
352 str += " faild, errCode:" + to_string(errCode);
353 }
354 str += " caller pid:" + to_string(callerInfo.pid)
355 + " uid:" + to_string(callerInfo.uid)
356 + " tokenID:" + to_string(callerInfo.tokenID)
357 + " bundleName:" + callerInfo.bundleName;
358 HiSysEventWrite(
359 HiviewDFX::HiSysEvent::Domain::CAMERA,
360 "CAMERA_ERR",
361 HiviewDFX::HiSysEvent::EventType::FAULT,
362 "MSG", str);
363 }
364
ReportUserBehavior(DFX_UB_NAME behaviorName,string value,CallerInfo callerInfo)365 void CameraReportUtils::ReportUserBehavior(DFX_UB_NAME behaviorName,
366 string value,
367 CallerInfo callerInfo)
368 {
369 unique_lock<mutex> lock(mutex_);
370 {
371 if (!IsBehaviorNeedReport(behaviorName, value)) {
372 MEDIA_DEBUG_LOG("ReportUserBehavior cancle");
373 return;
374 }
375 MEDIA_DEBUG_LOG("ReportUserBehavior");
376 const char* behaviorString = GetBehaviorImagingKey(behaviorName);
377 if (behaviorString == nullptr) {
378 MEDIA_ERR_LOG("ReportUserBehavior error imagingKey not found.");
379 return;
380 }
381 std::string str = "behaviorName:" + std::string(behaviorString)
382 + ",value:" + value
383 + ",curMode:" + to_string(curMode_)
384 + ",curCameraId:" + cameraId_
385 + ",cPid:" + to_string(callerInfo.pid)
386 + ",cUid:" + to_string(callerInfo.uid)
387 + ",cTokenID:" + to_string(callerInfo.tokenID)
388 + ",cBundleName:" + callerInfo.bundleName;
389
390 HiSysEventWrite(
391 HiviewDFX::HiSysEvent::Domain::CAMERA,
392 "USER_BEHAVIOR",
393 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
394 "MSG", str);
395 }
396 }
397
ReportImagingInfo(DfxCaptureInfo dfxCaptureInfo)398 void CameraReportUtils::ReportImagingInfo(DfxCaptureInfo dfxCaptureInfo)
399 {
400 MEDIA_DEBUG_LOG("ReportImagingInfo");
401 stringstream ss;
402 ss << "CurMode:" << curMode_ << ",CameraId:" << cameraId_ << ",Profile:" << profile_;
403 for (auto it = imagingValueList_.begin(); it != imagingValueList_.end(); it++) {
404 ss << "," << it->first << ":" << it->second;
405 }
406
407 HiSysEventWrite(
408 HiviewDFX::HiSysEvent::Domain::CAMERA,
409 "IMAGING_INFO",
410 HiviewDFX::HiSysEvent::EventType::STATISTIC,
411 "MSG", ss.str());
412 }
413
UpdateProfileInfo(const string & profileStr)414 void CameraReportUtils::UpdateProfileInfo(const string& profileStr)
415 {
416 profile_ = profileStr;
417 }
418
UpdateImagingInfo(const string & imagingKey,const string & value)419 void CameraReportUtils::UpdateImagingInfo(const string& imagingKey, const string& value)
420 {
421 auto it = imagingValueList_.find(imagingKey);
422 if (it != imagingValueList_.end()) {
423 it->second = value;
424 } else {
425 imagingValueList_.emplace(imagingKey, value);
426 }
427 }
428
IsBehaviorNeedReport(DFX_UB_NAME behaviorName,const string & value)429 bool CameraReportUtils::IsBehaviorNeedReport(DFX_UB_NAME behaviorName, const string& value)
430 {
431 const char* imagingKey = GetBehaviorImagingKey(behaviorName);
432 if (imagingKey == nullptr) {
433 MEDIA_ERR_LOG("IsBehaviorNeedReport error imagingKey not found.");
434 return true;
435 }
436 auto valueIt = imagingValueList_.find(imagingKey);
437 if (valueIt != imagingValueList_.end()) {
438 if (valueIt->second == value) {
439 return false;
440 } else {
441 valueIt->second = value;
442 return true;
443 }
444 } else {
445 imagingValueList_.emplace(imagingKey, value);
446 return true;
447 }
448 }
449
ResetImagingValue()450 void CameraReportUtils::ResetImagingValue()
451 {
452 imagingValueList_.clear();
453 }
454
SetVideoStartInfo(DfxCaptureInfo captureInfo)455 void CameraReportUtils::SetVideoStartInfo(DfxCaptureInfo captureInfo)
456 {
457 MEDIA_DEBUG_LOG("SetVideoStartInfo captureID: %{public}d", captureInfo.captureId);
458 captureInfo.captureStartTime = DeferredProcessing::SteadyClock::GetTimestampMilli();
459 unique_lock<mutex> lock(mutex_);
460 captureList_.insert(pair<int32_t, DfxCaptureInfo>(captureInfo.captureId, captureInfo));
461 }
462
SetVideoEndInfo(int32_t captureId)463 void CameraReportUtils::SetVideoEndInfo(int32_t captureId)
464 {
465 MEDIA_DEBUG_LOG("SetVideoEndInfo start");
466 unique_lock<mutex> lock(mutex_);
467 {
468 map<int32_t, DfxCaptureInfo>::iterator iter = captureList_.find(captureId);
469 if (iter != captureList_.end()) {
470 MEDIA_DEBUG_LOG("SetVideoEndInfo");
471 auto dfxCaptureInfo = iter->second;
472 dfxCaptureInfo.captureEndTime = DeferredProcessing::SteadyClock::GetTimestampMilli();
473 imagingValueList_.emplace("VideoDuration",
474 to_string(dfxCaptureInfo.captureEndTime - dfxCaptureInfo.captureStartTime));
475 ReportImagingInfo(dfxCaptureInfo);
476 captureList_.erase(captureId);
477 }
478 }
479 }
480
ReportUserBehaviorAddDevice(string behaviorName,string value,CallerInfo callerInfo)481 void CameraReportUtils::ReportUserBehaviorAddDevice(string behaviorName, string value, CallerInfo callerInfo)
482 {
483 unique_lock<mutex> lock(mutex_);
484 {
485 MEDIA_DEBUG_LOG("CameraReportUtils::ReportUserBehaviorAddDevice");
486 stringstream ss;
487 ss << "BEHAVIORNAME" << behaviorName
488 << ",MODE" << curMode_
489 << ",CAMERAID" << value
490 << ",PID" << callerInfo.pid
491 << ",UID" << callerInfo.uid
492 << ",TOKENID" << callerInfo.tokenID
493 << ",BUNDLENAME" << callerInfo.bundleName;
494
495 HiSysEventWrite(
496 HiviewDFX::HiSysEvent::Domain::CAMERA,
497 "USER_BEHAVIOR",
498 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
499 "MSG", ss.str());
500 }
501 }
502
ReportCameraErrorForUsb(string funcName,int32_t errCode,bool isHdiErr,string connectionType,CallerInfo callerInfo)503 void CameraReportUtils::ReportCameraErrorForUsb(string funcName,
504 int32_t errCode,
505 bool isHdiErr,
506 string connectionType,
507 CallerInfo callerInfo)
508 {
509 string str = funcName;
510 if (isHdiErr) {
511 str += " faild, hdi errCode:" + to_string(errCode);
512 } else {
513 str += " faild, errCode:" + to_string(errCode);
514 }
515 str += " caller pid:" + to_string(callerInfo.pid)
516 + " uid:" + to_string(callerInfo.uid)
517 + " tokenID:" + to_string(callerInfo.tokenID)
518 + " bundleName:" + callerInfo.bundleName;
519 + " connectionType:" + connectionType;
520 HiSysEventWrite(
521 HiviewDFX::HiSysEvent::Domain::CAMERA,
522 "CAMERA_ERR",
523 HiviewDFX::HiSysEvent::EventType::FAULT,
524 "MSG", str);
525 }
526 } // namespace CameraStandard
527 } // namespace OHOS
528