添加hisysevent打点信息

Signed-off-by: chen0088 <chenmenghuan3@huawei.com>

common/include/utils/dcamera_hisysevent_adapter.h

@@ -20,14 +20,22 @@
 
 namespace OHOS {
 namespace DistributedHardware {
-using EventStreamInfo = struct _EventStreamInfo {
-    int32_t streamId_;
-    int32_t width_;
-    int32_t height_;
-    int32_t format_;
-    int32_t encodeType_;
-    int32_t type_;
-};
+const std::string SA_ERROR = "DCAMERA_SA_START_FAIL";
+const std::string HDF_ERROR = "DCAMERA_HDF_START_FAIL";
+const std::string REGISTER_CAMERA_ERROR = "DCAMERA_REGISTER_FAIL";
+const std::string SOFTBUS_SESSIONSERVER_ERROR = "DCAMERA_CREATE_SESSIONSVR_FAIL";
+const std::string SOFTBUS_SESSION_ERROR = "DCAMERA_OPEN_SESSION_FAIL";
+const std::string SINK_OPEN_CAMERA_ERROR = "DCAMERA_SINK_OPEN_CAM_FAIL";
+const std::string START_VIDEO_ENCODER_ERROR = "DCAMERA_ENCODE_FAIL";
+const std::string START_VIDEO_DECODER_ERROR = "DCAMERA_DECODE_FAIL";
+
+const std::string INIT_SA_EVENT = "DCAMERA_INIT";
+const std::string RELEASE_SA_EVENT = "DCAMERA_EXIT";
+const std::string REGIST_CAMERA_EVENT = "DCAMERA_REGISTER";
+const std::string UNREGIST_CAMERA_EVENT = "DCAMERA_UNREGISTER";
+const std::string OPEN_CAMERA_EVENT = "DCAMERA_OPEN";
+const std::string CLOSE_CAMERA_EVENT = "DCAMERA_CLOSE";
+const std::string START_CAPTURE_EVENT = "DCAMERA_CAPTURE";
 
 using EventCaptureInfo = struct _EventCaptureInfo {
     int32_t width_;
@@ -38,29 +46,26 @@ using EventCaptureInfo = struct _EventCaptureInfo {
     int32_t type_;
 };
 
-void ReportLoadSaFail(int32_t saId, const std::string& errMsg);
-void ReportHDFFail(const std::string& errMsg);
-void ReportRegisterHardwareFail(const std::string& devId, const std::string& dhId,
+void ReportStartSaFail(const std::string eventName, int32_t saId, const std::string& errMsg);
+void ReportStartHDFFail(const std::string eventName, const std::string& errMsg);
+void ReportRegisterCameraFail(const std::string eventName, const std::string& devId, const std::string& dhId,
     std::string version, const std::string& errMsg);
-void ReportSoftbusSessionServerFail(const std::string& pkgName, std::string sessionName, const std::string& errMsg);
-void ReportSoftbusSessionFail(std::string mySessName, std::string peerSessName, std::string peerDevId,
-    const std::string& errMsg);
-void ReportCameraOperaterFail(const std::string& dhId, const std::string& errMsg);
-void ReportStartVideoEncoderFail(int32_t width, int32_t height, std::string format, const std::string& errMsg);
-void ReportStopVideoEncoderFail(const std::string& errMsg);
-void ReportStartVideoDecoderFail(int32_t width, int32_t height, std::string format, const std::string& errMsg);
-void ReportStopVideoDecoderFail(const std::string& errMsg);
+void ReportSoftbusSessionServerFail(const std::string eventName, const std::string& pkgName,
+    std::string sessionName, const std::string& errMsg);
+void ReportSoftbusSessionFail(const std::string eventName, std::string mySessName,
+    std::string peerSessName, std::string peerDevId, const std::string& errMsg);
+void ReportSinkOpenCamFail(const std::string eventName, const std::string& dhId, const std::string& errMsg);
+void ReportStartVideoEncoderFail(const std::string eventName, int32_t width, int32_t height,
+    std::string format, const std::string& errMsg);
+void ReportStartVideoDecoderFail(const std::string eventName, int32_t width, int32_t height,
+    std::string format, const std::string& errMsg);
 
 void ReportSaEvent(const std::string eventName, int32_t saId, const std::string& errMsg);
-void ReportHDFEvent(const std::string eventName, const std::string& errMsg);
 void ReportRegisterCameraEvent(const std::string eventName, const std::string& devId, const std::string& dhId,
     std::string version, const std::string& errMsg);
 void ReportCameraOperaterEvent(const std::string eventName, const std::string& devId, const std::string& dhId,
     const std::string& errMsg);
-void ReportConfigStreamsEvent(EventStreamInfo& streamInfo, const std::string& errMsg);
-void ReportReleaseStreamsEvent(int32_t streamId, const std::string& errMsg);
-void ReportStartCaptureEvent(EventCaptureInfo& capture, const std::string& errMsg);
-void ReportStopCaptureEvent(int32_t streamId, const std::string& errMsg);
+void ReportStartCaptureEvent(const std::string eventName, EventCaptureInfo& capture, const std::string& errMsg);
 } // namespace DistributedHardware
 } // namespace OHOS
 #endif // OHOS_DCAMERA_HISYSEVENT_ADAPTER_H

common/src/utils/dcamera_hisysevent_adapter.cpp

@@ -32,10 +32,10 @@ const std::string ENUM_ENCODETYPE_STRINGS[] = {
 };
 }
 
-void ReportLoadSaFail(int32_t saId, const std::string& errMsg)
+void ReportStartSaFail(const std::string eventName, int32_t saId, const std::string& errMsg)
 {
     int ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "SA_ERROR",
+        eventName,
         HiSysEventNameSpace::EventType::FAULT,
         "SAID", saId,
         "MSG", errMsg);
@@ -44,10 +44,10 @@ void ReportLoadSaFail(int32_t saId, const std::string& errMsg)
     }
 }
 
-void ReportHDFFail(const std::string& errMsg)
+void ReportStartHDFFail(const std::string eventName, const std::string& errMsg)
 {
     int ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "HDF_ERROR",
+        eventName,
         HiSysEventNameSpace::EventType::FAULT,
         "MSG", errMsg);
     if (ret != DCAMERA_OK) {
@@ -55,11 +55,11 @@ void ReportHDFFail(const std::string& errMsg)
     }
 }
 
-void ReportRegisterHardwareFail(const std::string& devId, const std::string& dhId,
+void ReportRegisterCameraFail(const std::string eventName, const std::string& devId, const std::string& dhId,
     std::string version, const std::string& errMsg)
 {
     int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "REGISTER_HARDWARE_ERROR",
+        eventName,
         HiSysEventNameSpace::EventType::FAULT,
         "DEVID", devId,
         "DHID", dhId,
@@ -71,10 +71,11 @@ void ReportRegisterHardwareFail(const std::string& devId, const std::string& dhI
     }
 }
 
-void ReportSoftbusSessionServerFail(const std::string& pkgName, std::string sessionName, const std::string& errMsg)
+void ReportSoftbusSessionServerFail(const std::string eventName, const std::string& pkgName,
+    std::string sessionName, const std::string& errMsg)
 {
     int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "SOFTBUS_SESSIONSERVER_ERROR",
+        eventName,
         HiSysEventNameSpace::EventType::FAULT,
         "PKGNAME", pkgName,
         "SESSIONNAME", sessionName,
@@ -84,11 +85,11 @@ void ReportSoftbusSessionServerFail(const std::string& pkgName, std::string sess
     }
 }
 
-void ReportSoftbusSessionFail(std::string mySessName, std::string peerSessName, std::string peerDevId,
-    const std::string& errMsg)
+void ReportSoftbusSessionFail(const std::string eventName, std::string mySessName,
+    std::string peerSessName, std::string peerDevId, const std::string& errMsg)
 {
     int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "SOFTBUS_SESSION_ERROR",
+        eventName,
         HiSysEventNameSpace::EventType::FAULT,
         "MYSESSIONNAME", mySessName,
         "PEERSESSIONNAME", peerSessName,
@@ -99,10 +100,10 @@ void ReportSoftbusSessionFail(std::string mySessName, std::string peerSessName,
     }
 }
 
-void ReportCameraOperaterFail(const std::string& dhId, const std::string& errMsg)
+void ReportSinkOpenCamFail(const std::string eventName, const std::string& dhId, const std::string& errMsg)
 {
     int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "CAMERA_OPERATER_ERROR",
+        eventName,
         HiSysEventNameSpace::EventType::FAULT,
         "DHID", dhId,
         "MSG", errMsg);
@@ -111,10 +112,11 @@ void ReportCameraOperaterFail(const std::string& dhId, const std::string& errMsg
     }
 }
 
-void ReportStartVideoEncoderFail(int32_t width, int32_t height, std::string format, const std::string& errMsg)
+void ReportStartVideoEncoderFail(const std::string eventName, int32_t width, int32_t height,
+    std::string format, const std::string& errMsg)
 {
     int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "START_VIDEO_ENCODER_ERROR",
+        eventName,
         HiSysEventNameSpace::EventType::FAULT,
         "WIDTH", width,
         "HEIGHT", height,
@@ -125,21 +127,11 @@ void ReportStartVideoEncoderFail(int32_t width, int32_t height, std::string form
     }
 }
 
-void ReportStopVideoEncoderFail(const std::string& errMsg)
+void ReportStartVideoDecoderFail(const std::string eventName, int32_t width, int32_t height,
+    std::string format, const std::string& errMsg)
 {
     int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "STOP_VIDEO_ENCODER_ERROR",
-        HiSysEventNameSpace::EventType::FAULT,
-        "MSG", errMsg);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
-    }
-}
-
-void ReportStartVideoDecoderFail(int32_t width, int32_t height, std::string format, const std::string& errMsg)
-{
-    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "START_VIDEO_DECODER_ERROR",
+        eventName,
         HiSysEventNameSpace::EventType::FAULT,
         "WIDTH", width,
         "HEIGHT", height,
@@ -150,17 +142,6 @@ void ReportStartVideoDecoderFail(int32_t width, int32_t height, std::string form
     }
 }
 
-void ReportStopVideoDecoderFail(const std::string& errMsg)
-{
-    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "STOP_VIDEO_DECODER_ERROR",
-        HiSysEventNameSpace::EventType::FAULT,
-        "MSG", errMsg);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
-    }
-}
-
 void ReportSaEvent(const std::string eventName, int32_t saId, const std::string& errMsg)
 {
     int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
@@ -173,17 +154,6 @@ void ReportSaEvent(const std::string eventName, int32_t saId, const std::string&
     }
 }
 
-void ReportHDFEvent(const std::string eventName, const std::string& errMsg)
-{
-    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        eventName,
-        HiSysEventNameSpace::EventType::BEHAVIOR,
-        "MSG", errMsg);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
-    }
-}
-
 void ReportRegisterCameraEvent(const std::string eventName, const std::string& devId, const std::string& dhId,
     std::string version, const std::string& errMsg)
 {
@@ -213,39 +183,10 @@ void ReportCameraOperaterEvent(const std::string eventName, const std::string& d
     }
 }
 
-void ReportConfigStreamsEvent(EventStreamInfo& streamInfo, const std::string& errMsg)
+void ReportStartCaptureEvent(const std::string eventName, EventCaptureInfo& capture, const std::string& errMsg)
 {
     int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "CONFIG_STREAMS_EVENT",
-        HiSysEventNameSpace::EventType::BEHAVIOR,
-        "STREAMID", streamInfo.streamId_,
-        "WIDTH", streamInfo.width_,
-        "HEIGHT", streamInfo.height_,
-        "FORMAT", streamInfo.format_,
-        "ENCODETYPE", ENUM_ENCODETYPE_STRINGS[streamInfo.encodeType_],
-        "STREAMTYPE", ENUM_STREAMTYPE_STRINGS[streamInfo.type_],
-        "MSG", errMsg);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
-    }
-}
-
-void ReportReleaseStreamsEvent(int32_t streamId, const std::string& errMsg)
-{
-    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "RELEASE_STREAMS_EVENT",
-        HiSysEventNameSpace::EventType::BEHAVIOR,
-        "STREAMID", streamId,
-        "MSG", errMsg);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
-    }
-}
-
-void ReportStartCaptureEvent(EventCaptureInfo& capture, const std::string& errMsg)
-{
-    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "START_CAPTURE_EVENT",
+        eventName,
         HiSysEventNameSpace::EventType::BEHAVIOR,
         "WIDTH", capture.width_,
         "HEIGHT", capture.height_,
@@ -258,17 +199,5 @@ void ReportStartCaptureEvent(EventCaptureInfo& capture, const std::string& errMs
         DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
     }
 }
-
-void ReportStopCaptureEvent(int32_t streamId, const std::string& errMsg)
-{
-    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
-        "STOP_CAPTURE_EVENT",
-        HiSysEventNameSpace::EventType::BEHAVIOR,
-        "STREAMID", streamId,
-        "MSG", errMsg);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
-    }
-}
 } // namespace DistributedHardware
 } // namespace OHOS

hisysevent.yaml

@@ -39,132 +39,96 @@
 
 domain: DISTCAMERA
 
-SA_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera sa error occured}
+DCAMERA_SA_START_FAIL:
+  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera sa start error occured}
   SAID: {type: INT32, desc: dcamera SAID}
   MSG: {type: STRING, desc: dcamera sa error info}
 
-HDF_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera hdf error occured}
+DCAMERA_HDF_START_FAIL:
+  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera hdf start error occured}
   MSG: {type: STRING, desc: dcamera hdf error info}
 
-REGISTER_HARDWARE_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: register dcamera error occured}
+DCAMERA_REGISTER_FAIL:
+  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera register error occured}
   DEVID: {type: STRING, desc: dcamera devId}
   DHID: {type: STRING, desc: dcamera dhId}
   VERSION: {type: STRING, desc: dcamera version}
   MSG: {type: STRING, desc: register dcamera error info}
 
-SOFTBUS_SESSIONSERVER_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: softbus sessionserver error occured}
+DCAMERA_CREATE_SESSIONSVR_FAIL:
+  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera softbus sessionserver error occured}
   PKGNAME: {type: STRING, desc: softbus package name}
   SESSIONNAME: {type: STRING, desc: softbus session name}
   MSG: {type: STRING, desc: dcamera softbus sessionserver error info}
 
-SOFTBUS_SESSION_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: softbus session error occured}
+DCAMERA_OPEN_SESSION_FAIL:
+  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera softbus session error occured}
   MYSESSIONNAME: {type: STRING, desc: softbus my session name}
   PEERSESSIONNAME: {type: STRING, desc: softbus peer session name}
   PEERDEVID: {type: STRING, desc: peer network id}
   MSG: {type: STRING, desc: dcamera softbus session error info}
 
-CAMERA_OPERATER_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera operater error occured}
+DCAMERA_SINK_OPEN_CAM_FAIL:
+  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera sink open camera error occured}
   DHID: {type: STRING, desc: dcamera dhId}
-  MSG: {type: STRING, desc: dcamera operater error info}
+  MSG: {type: STRING, desc: dcamera sink open camera error info}
 
-START_VIDEO_ENCODER_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: video encoder error occured}
+DCAMERA_ENCODE_FAIL:
+  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera video encoder error occured}
   WIDTH: {type: INT32, desc: dcamera width}
   HEIGHT: {type: INT32, desc: dcamera height}
   FORMAT: {type: STRING, desc: dcamera FORMAT}
   MSG: {type: STRING, desc: dcamera video encoder error info}
 
-STOP_VIDEO_ENCODER_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: video encoder error occured}
-  MSG: {type: STRING, desc: dcamera video encoder error info}
-
-START_VIDEO_DECODER_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: video decoder error occured}
+DCAMERA_DECODE_FAIL:
+  __BASE: {type: FAULT, level: CRITICAL, desc: dcamera video decoder error occured}
   WIDTH: {type: INT32, desc: dcamera width}
   HEIGHT: {type: INT32, desc: dcamera height}
   FORMAT: {type: STRING, desc: dcamera format}
   MSG: {type: STRING, desc: dcamera video decoder error info}
 
-STOP_VIDEO_DECODER_ERROR:
-  __BASE: {type: FAULT, level: CRITICAL, desc: video decoder error occured}
-  MSG: {type: STRING, desc: dcamera video encoder error info}
-
-INIT_SA_EVENT:
+DCAMERA_INIT:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera init sa event}
   SAID: {type: INT32, desc: dcamera SAID}
   MSG: {type: STRING, desc: dcamera init sa event}
 
-RELEASE_SA_EVENT:
+DCAMERA_EXIT:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera release sa event}
   SAID: {type: INT32, desc: dcamera SAID}
   MSG: {type: STRING, desc: dcamera release sa event}
 
-LOAD_HDF_EVENT:
-  __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera load hdf event}
-  MSG: {type: STRING, desc: dcamera load hdf event}
-
-UNLOAD_HDF_EVENT:
-  __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera unload hdf event}
-  MSG: {type: STRING, desc: dcamera unload hdf event}
-
-REGIST_CAMERA_EVENT:
+DCAMERA_REGISTER:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera register event}
   DEVID: {type: STRING, desc: dcamera devId}
   DHID: {type: STRING, desc: dcamera dhId}
   VERSION: {type: STRING, desc: dcamera version}
   MSG: {type: STRING, desc: dcamera register event}
 
-UNREGIST_CAMERA_EVENT:
+DCAMERA_UNREGISTER:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera unregister event}
   DEVID: {type: STRING, desc: dcamera devId}
   DHID: {type: STRING, desc: dcamera dhId}
   VERSION: {type: STRING, desc: dcamera version}
   MSG: {type: STRING, desc: dcamera unregister event}
  
-OPEN_CAMERA_EVENT:
+DCAMERA_OPEN:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera open event}
   DEVID: {type: STRING, desc: dcamera devId}
   DHID: {type: STRING, desc: dcamera dhId}
   MSG: {type: STRING, desc: dcamera open event}
 
-CLOSE_CAMERA_EVENT:
+DCAMERA_CLOSE:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera close event}
   DEVID: {type: STRING, desc: dcamera devId}
   DHID: {type: STRING, desc: dcamera dhId}
   MSG: {type: STRING, desc: dcamera close event}
 
-CONFIG_STREAMS_EVENT:
-  __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera config streams event}
-  STREAMID: {type: INT32, desc: dcamera streamId}
-  WIDTH: {type: INT32, desc: dcamera width}
-  HEIGHT: {type: INT32, desc: dcamera height}
-  FORMAT: {type: INT32, desc: dcamera format}
-  ENCODETYPE: {type: STRING, desc: dcamera encodeType}
-  STREAMTYPE: {type: STRING, desc: dcamera streamType}
-  MSG: {type: STRING, desc: dcamera config streams event}
-
-RELEASE_STREAMS_EVENT:
-  __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera release streams event}
-  STREAMID: {type: INT32, desc: dcamera streamId}
-  MSG: {type: STRING, desc: dcamera release streams event}
-
-START_CAPTURE_EVENT:
-  __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera start capture event}
+DCAMERA_CAPTURE:
+  __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera capture event}
   WIDTH: {type: INT32, desc: dcamera width}
   HEIGHT: {type: INT32, desc: dcamera height}
   FORMAT: {type: INT32, desc: dcamera format}
   ISCAPTURE: {type: STRING, desc: dcamera isCapture}
   ENCODETYPE: {type: STRING, desc: dcamera encodeType}
   STREAMTYPE: {type: STRING, desc: dcamera streamType}
-  MSG: {type: STRING, desc: dcamera start capture event}
-
-STOP_CAPTURE_EVENT:
-  __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera stop capture event}
-  STREAMID: {type: INT32, desc: dcamera streamId}
-  MSG: {type: STRING, desc: dcamera stop capture event}
+  MSG: {type: STRING, desc: dcamera capture event}

interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_handler.cpp

@@ -42,7 +42,7 @@ int32_t DCameraSinkHandler::InitSink(const std::string& params)
         DHLOGE("GetSourceLocalDHMS GetSystemAbilityManager failed");
         return DCAMERA_INIT_ERR;
     }
-    ReportSaEvent("INIT_SA_EVENT", DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, "init sink sa event.");
+    ReportSaEvent(INIT_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, "init sink sa event.");
     sptr<DCameraSinkLoadCallback> loadCallback = new DCameraSinkLoadCallback(params);
     int32_t ret = sm->LoadSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, loadCallback);
     if (ret != DCAMERA_OK) {
@@ -93,7 +93,7 @@ int32_t DCameraSinkHandler::ReleaseSink()
         return DCAMERA_BAD_VALUE;
     }
 
-    ReportSaEvent("RELEASE_SA_EVENT", DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, "release sink sa event.");
+    ReportSaEvent(RELEASE_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, "release sink sa event.");
     int32_t ret = dCameraSinkSrv->ReleaseSink();
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSinkHandler::ReleaseSink sink service release failed, ret: %d", ret);

interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_load_callback.cpp

@@ -44,7 +44,7 @@ void DCameraSinkLoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
     DHLOGI("OnLoadSystemAbilityFail systemAbilityId: %d.", systemAbilityId);
     if (systemAbilityId != DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID) {
         DHLOGE("start aystemabilityId is not sinkSAId!");
-        ReportLoadSaFail(systemAbilityId, "dcamera sink OnLoadSystemAbilityFail.");
+        ReportStartSaFail(SA_ERROR, systemAbilityId, "dcamera sink OnLoadSystemAbilityFail.");
         return;
     }
     DCameraSinkHandler::GetInstance().FinishStartSAFailed(systemAbilityId);

interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp

@@ -44,7 +44,7 @@ int32_t DCameraSourceHandler::InitSource(const std::string& params)
         DHLOGE("GetSourceLocalDHMS GetSystemAbilityManager failed");
         return DCAMERA_INIT_ERR;
     }
-    ReportSaEvent("INIT_SA_EVENT", DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "init source sa event.");
+    ReportSaEvent(INIT_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "init source sa event.");
     sptr<DCameraSourceLoadCallback> loadCallback = new DCameraSourceLoadCallback(params);
     int32_t ret = sm->LoadSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, loadCallback);
     if (ret != DCAMERA_OK) {
@@ -100,7 +100,7 @@ int32_t DCameraSourceHandler::ReleaseSource()
         DHLOGE("DCameraSourceHandler ReleaseSource get Service failed");
         return DCAMERA_INIT_ERR;
     }
-    ReportSaEvent("RELEASE_SA_EVENT", DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "release source sa event.");
+    ReportSaEvent(RELEASE_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "release source sa event.");
     dCameraSourceSrv->ReleaseSource();
     DCameraSourceHandlerIpc::GetInstance().UnInit();
     std::unique_lock<std::mutex> lock(producerMutex_);

interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_load_callback.cpp

@@ -44,7 +44,7 @@ void DCameraSourceLoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
     DHLOGI("OnLoadSystemAbilityFail systemAbilityId: %d.", systemAbilityId);
     if (systemAbilityId != DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID) {
         DHLOGE("start systemabilityId is not sourceSAId!");
-        ReportLoadSaFail(systemAbilityId, "dcamera source OnLoadSystemAbilityFail.");
+        ReportStartSaFail(SA_ERROR, systemAbilityId, "dcamera source OnLoadSystemAbilityFail.");
         return;
     }
     DCameraSourceHandler::GetInstance().FinishStartSAFailed(systemAbilityId);

services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp

@@ -236,7 +236,7 @@ int32_t DistributedCameraSinkService::OpenChannel(const std::string& dhId, std::
     int32_t ret = sinkDevice->OpenChannel(openInfo);
     if (ret != DCAMERA_OK) {
         DHLOGE("DistributedCameraSinkService::OpenChannel failed, ret: %d", ret);
-        ReportCameraOperaterFail(dhId, "sink service open channel failed.");
+        ReportSinkOpenCamFail(SINK_OPEN_CAMERA_ERROR, dhId, "sink service open channel failed.");
         return ret;
     }
     DHLOGI("DistributedCameraSinkService::OpenChannel success");

services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp

@@ -88,7 +88,6 @@ int32_t DistributedCameraSourceService::InitSource(const std::string& params,
     const sptr<IDCameraSourceCallback>& callback)
 {
     DHLOGI("DistributedCameraSourceService InitSource param: %s", params.c_str());
-    ReportHDFEvent("LOAD_HDF_EVENT", "load dcamera hdf event.");
     int32_t ret = LoadDCameraHDF();
     if (ret != DCAMERA_OK) {
         DHLOGE("DistributedCameraSourceService InitSource LoadHDF failed, ret: %d", ret);
@@ -102,7 +101,6 @@ int32_t DistributedCameraSourceService::InitSource(const std::string& params,
 int32_t DistributedCameraSourceService::ReleaseSource()
 {
     DHLOGI("DistributedCameraSourceService ReleaseSource");
-    ReportHDFEvent("UNLOAD_HDF_EVENT", "unload dcamera hdf event.");
     int32_t ret = UnLoadCameraHDF();
     if (ret != DCAMERA_OK) {
         DHLOGE("DistributedCameraSourceService ReleaseSource UnLoadHDF failed, ret: %d", ret);
@@ -145,7 +143,7 @@ int32_t DistributedCameraSourceService::RegisterDistributedHardware(const std::s
     ret = camDev->RegisterDistributedHardware(devId, dhId, reqId, param.version, param.attrs);
     if (ret != DCAMERA_OK) {
         DHLOGE("DistributedCameraSourceService RegisterDistributedHardware failed, ret: %d", ret);
-        ReportRegisterHardwareFail(GetAnonyString(devId), dhId, param.version,
+        ReportRegisterCameraFail(REGISTER_CAMERA_ERROR, GetAnonyString(devId), dhId, param.version,
             "dcamera source RegisterDistributedHardware fail.");
         camerasMap_.erase(camIndex);
     }
@@ -200,7 +198,7 @@ int32_t DistributedCameraSourceService::LoadDCameraHDF()
     int32_t ret = DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl();
     if (ret != DCAMERA_OK) {
         DHLOGE("load hdf driver failed, ret %d", ret);
-        ReportHDFFail("dcamera load hdf driver fail.");
+        ReportStartHDFFail(HDF_ERROR, "dcamera load hdf driver fail.");
         return ret;
     }
     DHLOGI("load hdf driver end");
@@ -213,7 +211,6 @@ int32_t DistributedCameraSourceService::UnLoadCameraHDF()
     int32_t ret = DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl();
     if (ret != DCAMERA_OK) {
         DHLOGE("unload hdf driver failed, ret %d", ret);
-        ReportHDFFail("dcamera unload hdf driver fail.");
         return ret;
     }
     DHLOGI("unload hdf driver end");

services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp

@@ -216,7 +216,7 @@ int32_t DCameraSourceDev::ExecuteRegister(std::shared_ptr<DCameraRegistParam>& p
 {
     DHLOGI("DCameraSourceDev Execute Register devId: %s dhId: %s",
         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
-    ReportRegisterCameraEvent("REGIST_CAMERA_EVENT", GetAnonyString(devId_), dhId_,
+    ReportRegisterCameraEvent(REGIST_CAMERA_EVENT, GetAnonyString(devId_), dhId_,
         version_, "execute register event.");
     std::vector<DCameraIndex> actualDevInfo;
     actualDevInfo.assign(actualDevInfo_.begin(), actualDevInfo_.end());
@@ -261,7 +261,7 @@ int32_t DCameraSourceDev::ExecuteUnRegister(std::shared_ptr<DCameraRegistParam>&
 {
     DHLOGI("DCameraSourceDev Execute UnRegister devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    ReportRegisterCameraEvent("UNREGIST_CAMERA_EVENT", GetAnonyString(devId_), dhId_,
+    ReportRegisterCameraEvent(UNREGIST_CAMERA_EVENT, GetAnonyString(devId_), dhId_,
         version_, "execute unregister event.");
     int32_t ret = controller_->UnInit();
     if (ret != DCAMERA_OK) {
@@ -298,7 +298,7 @@ int32_t DCameraSourceDev::ExecuteOpenCamera()
 {
     DHLOGI("DCameraSourceDev Execute OpenCamera devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    ReportCameraOperaterEvent("OPEN_CAMERA_EVENT", GetAnonyString(devId_), dhId_, "execute open camera event.");
+    ReportCameraOperaterEvent(OPEN_CAMERA_EVENT, GetAnonyString(devId_), dhId_, "execute open camera event.");
     std::shared_ptr<DCameraOpenInfo> openInfo = std::make_shared<DCameraOpenInfo>();
     int32_t ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_);
     if (ret != DCAMERA_OK) {
@@ -320,7 +320,7 @@ int32_t DCameraSourceDev::ExecuteCloseCamera()
 {
     DHLOGI("DCameraSourceDev Execute CloseCamera devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    ReportCameraOperaterEvent("CLOSE_CAMERA_EVENT", GetAnonyString(devId_), dhId_, "execute close camera event.");
+    ReportCameraOperaterEvent(CLOSE_CAMERA_EVENT, GetAnonyString(devId_), dhId_, "execute close camera event.");
     int32_t ret = input_->CloseChannel();
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceDev Execute CloseCamera input CloseChannel failed, ret: %d, devId: %s dhId: %s", ret,
@@ -338,18 +338,6 @@ int32_t DCameraSourceDev::ExecuteConfigStreams(std::vector<std::shared_ptr<DCStr
 {
     DHLOGI("DCameraSourceDev Execute ConfigStreams devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    for (auto iter = streamInfos.begin(); iter != streamInfos.end(); iter++) {
-        std::shared_ptr<DCStreamInfo> streamInfo = *iter;
-        EventStreamInfo eventStreamInfo = {
-            .streamId_ = streamInfo->streamId_,
-            .width_ = streamInfo->width_,
-            .height_ = streamInfo->height_,
-            .format_ = streamInfo->format_,
-            .encodeType_ = streamInfo->encodeType_,
-            .type_ = streamInfo->type_,
-        };
-        ReportConfigStreamsEvent(eventStreamInfo, "execute config streams event.");
-    }
     int32_t ret = input_->ConfigStreams(streamInfos);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceDev Execute ConfigStreams ConfigStreams failed, ret: %d, devId: %s dhId: %s", ret,
@@ -391,9 +379,6 @@ int32_t DCameraSourceDev::ExecuteReleaseStreams(std::vector<int>& streamIds, boo
 {
     DHLOGI("DCameraSourceDev Execute ReleaseStreams devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    for (auto iter = streamIds.begin(); iter != streamIds.end(); iter++) {
-        ReportReleaseStreamsEvent(*iter, "execute release streams event.");
-    }
     int32_t ret = input_->ReleaseStreams(streamIds, isAllRelease);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceDev Execute ReleaseStreams failed ret: %d, devId: %s, dhId: %s", ret,
@@ -448,7 +433,7 @@ int32_t DCameraSourceDev::ExecuteStartCapture(std::vector<std::shared_ptr<DCCapt
             .encodeType_ = capture->encodeType_,
             .type_ = capture->streamType_,
         };
-        ReportStartCaptureEvent(eventCaptureInfo, "execute start capture event.");
+        ReportStartCaptureEvent(START_CAPTURE_EVENT, eventCaptureInfo, "execute start capture event.");
         for (auto settingIter = (*iter)->captureSettings_.begin(); settingIter != (*iter)->captureSettings_.end();
             settingIter++) {
             std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
@@ -471,9 +456,6 @@ int32_t DCameraSourceDev::ExecuteStopCapture(std::vector<int>& streamIds, bool&
 {
     DHLOGI("DCameraSourceDev Execute StopCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    for (auto iter = streamIds.begin(); iter != streamIds.end(); iter++) {
-        ReportStopCaptureEvent(*iter, "execute stop capture event.");
-    }
     int32_t ret = input_->StopCapture(streamIds, isAllStop);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceDev Execute StopCapture input StopCapture failed, ret: %d, devId: %s dhId: %s", ret,

services/channel/src/dcamera_softbus_adapter.cpp

@@ -126,7 +126,8 @@ int32_t DCameraSoftbusAdapter::CreateSoftbusSessionServer(std::string sessionNam
     int32_t ret = CreateSessionServer(PKG_NAME.c_str(), sessionName.c_str(), &sessListeners_[role]);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSoftbusAdapter CreateSessionServer failed, ret: %d", ret);
-        ReportSoftbusSessionServerFail(PKG_NAME, sessionName, "create session server failed");
+        ReportSoftbusSessionServerFail(SOFTBUS_SESSIONSERVER_ERROR, PKG_NAME,
+            sessionName, "create session server failed");
         return ret;
     }
     sessionTotal_[sessionName]++;
@@ -199,7 +200,8 @@ int32_t DCameraSoftbusAdapter::OpenSoftbusSession(std::string mySessName, std::s
     int32_t sessionId = OpenSession(mySessName.c_str(), peerSessName.c_str(), peerDevId.c_str(), "0", &attr);
     if (sessionId < 0) {
         DHLOGE("DCameraSoftbusAdapter OpenSoftbusSession failed %d", sessionId);
-        ReportSoftbusSessionFail(mySessName, peerSessName, peerDevId, "open softbus session failed.");
+        ReportSoftbusSessionFail(SOFTBUS_SESSION_ERROR, mySessName, peerSessName,
+            peerDevId, "open softbus session failed.");
         return DCAMERA_BAD_OPERATE;
     }
     return DCAMERA_OK;

services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp

@@ -111,7 +111,7 @@ int32_t DecodeDataProcess::InitDecoder()
     ret = StartVideoDecoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("Start Video decoder failed.");
-        ReportStartVideoDecoderFail(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
+        ReportStartVideoDecoderFail(START_VIDEO_DECODER_ERROR, sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
             ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())],
             "start video decoder failed.");
         return ret;
@@ -281,7 +281,6 @@ void DecodeDataProcess::ReleaseVideoDecoder()
     int32_t ret = StopVideoDecoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("StopVideoDecoder failed.");
-        ReportStopVideoDecoderFail("stop video decoder failed.");
     }
     ret = videoDecoder_->Release();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {

services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp

@@ -111,7 +111,7 @@ int32_t DecodeDataProcess::InitDecoder()
     ret = StartVideoDecoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("Start Video decoder failed.");
-        ReportStartVideoDecoderFail(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
+        ReportStartVideoDecoderFail(START_VIDEO_DECODER_ERROR, sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
             ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())],
             "start video decoder failed.");
         return ret;
@@ -270,7 +270,6 @@ void DecodeDataProcess::ReleaseVideoDecoder()
     int32_t ret = StopVideoDecoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("StopVideoDecoder failed.");
-        ReportStopVideoDecoderFail("stop video decoder failed.");
     }
     ret = videoDecoder_->Release();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {

services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp

@@ -116,7 +116,7 @@ int32_t EncodeDataProcess::InitEncoder()
     ret = StartVideoEncoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("Start Video encoder failed.");
-        ReportStartVideoEncoderFail(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
+        ReportStartVideoEncoderFail(START_VIDEO_ENCODER_ERROR, sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
             ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())],
             "start video encoder failed.");
         return ret;
@@ -306,7 +306,6 @@ void EncodeDataProcess::ReleaseVideoEncoder()
     int32_t ret = StopVideoEncoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("StopVideoEncoder failed.");
-        ReportStopVideoEncoderFail("stop video encoder failed.");
     }
     ret = videoEncoder_->Release();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {

services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process_common.cpp

@@ -116,7 +116,7 @@ int32_t EncodeDataProcess::InitEncoder()
     ret = StartVideoEncoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("Start Video encoder failed.");
-        ReportStartVideoEncoderFail(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
+        ReportStartVideoEncoderFail(START_VIDEO_ENCODER_ERROR, sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
             ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())],
             "start video encoder failed.");
         return ret;
@@ -278,7 +278,6 @@ void EncodeDataProcess::ReleaseVideoEncoder()
     int32_t ret = StopVideoEncoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("StopVideoEncoder failed.");
-        ReportStopVideoEncoderFail("stop video encoder failed.");
     }
     ret = videoEncoder_->Release();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {