diff --git a/common/BUILD.gn b/common/BUILD.gn
index 880aafd..9d8df6c 100644
--- a/common/BUILD.gn
+++ b/common/BUILD.gn
@@ -32,6 +32,7 @@ ohos_shared_library("distributed_camera_utils") {
 
   sources = [
     "src/utils/data_buffer.cpp",
+    "src/utils/dcamera_hisysevent_adapter.cpp",
     "src/utils/dcamera_sa_process_state.cpp",
     "src/utils/dcamera_utils_tools.cpp",
   ]
@@ -49,6 +50,7 @@ ohos_shared_library("distributed_camera_utils") {
 
   external_deps = [
     "dsoftbus_standard:softbus_client",
+    "hisysevent_native:libhisysevent",
     "hiviewdfx_hilog_native:libhilog",
   ]
 
diff --git a/common/include/utils/dcamera_hisysevent_adapter.h b/common/include/utils/dcamera_hisysevent_adapter.h
new file mode 100644
index 0000000..2a92a84
--- /dev/null
+++ b/common/include/utils/dcamera_hisysevent_adapter.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DCAMERA_HISYSEVENT_ADAPTER_H
+#define OHOS_DCAMERA_HISYSEVENT_ADAPTER_H
+
+#include <string>
+
+namespace OHOS {
+namespace DistributedHardware {
+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,
+    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 ReportInitSaEvent(int32_t saId, const std::string& errMsg);
+void ReportReleaseSaEvent(const std::string& errMsg);
+void ReportLoadHDFEvent(const std::string& errMsg);
+void ReportUnLoadHDFEvent(const std::string& errMsg);
+void ReportRegisterCameraEvent(const std::string& devId, const std::string& dhId,
+    std::string version, const std::string& errMsg);
+void ReportUnRegisterCameraEvent(const std::string& devId, const std::string& dhId, const std::string& errMsg);
+void ReportOpenCameraEvent(const std::string& devId, const std::string& dhId, const std::string& errMsg);
+void ReportCloseCameraEvent(const std::string& devId, const std::string& dhId, const std::string& errMsg);
+void ReportConfigStreamsEvent(int32_t streamId, int32_t width, int32_t height, int32_t format,
+    std::string encodeType, std::string streamType, const std::string& errMsg);
+void ReportReleaseStreamsEvent(int32_t streamId, const std::string& errMsg);
+void ReportStartCaptureEvent(int32_t width, int32_t height, int32_t format, std::string isCapture,
+    std::string encodeType, std::string streamType, const std::string& errMsg);
+void ReportStopCaptureEvent(int32_t streamId, const std::string& errMsg);
+} // namespace DistributedHardware
+} // namespace OHOS
+#endif // OHOS_DCAMERA_HISYSEVENT_ADAPTER_H
\ No newline at end of file
diff --git a/common/src/utils/dcamera_hisysevent_adapter.cpp b/common/src/utils/dcamera_hisysevent_adapter.cpp
new file mode 100644
index 0000000..01618c9
--- /dev/null
+++ b/common/src/utils/dcamera_hisysevent_adapter.cpp
@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dcamera_hisysevent_adapter.h"
+
+#include "hisysevent.h"
+#include "distributed_camera_errno.h"
+#include "distributed_hardware_log.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+namespace {
+using HiSysEventNameSpace = OHOS::HiviewDFX::HiSysEvent;
+const std::string DOMAIN_STR = std::string(HiSysEventNameSpace::Domain::DISTRIBUTED_CAMERA);
+}
+
+void ReportLoadSaFail(int32_t saId, const std::string& errMsg)
+{
+    int ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "SA_ERROR",
+        HiSysEventNameSpace::EventType::FAULT,
+        "SAID", saId,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error ret %d, saId %d, errMsg %s.", ret, saId, errMsg.c_str());
+    }
+}
+
+void ReportHDFFail(const std::string& errMsg)
+{
+    int ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "HDF_ERROR",
+        HiSysEventNameSpace::EventType::FAULT,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error ret %d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportRegisterHardwareFail(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",
+        HiSysEventNameSpace::EventType::FAULT,
+        "DEVID", devId,
+        "DHID", dhId,
+        "VERSION", version,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error ret %d, devId %s, dhId %s, errMsg %s.", ret, devId.c_str(),
+            dhId.c_str(), errMsg.c_str());
+    }
+}
+
+void ReportSoftbusSessionServerFail(const std::string pkgName, std::string sessionName, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "SOFTBUS_SESSIONSERVER_ERROR",
+        HiSysEventNameSpace::EventType::FAULT,
+        "PKGNAME", pkgName,
+        "SESSIONNAME", sessionName,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportSoftbusSessionFail(std::string mySessName, std::string peerSessName, std::string peerDevId,
+    const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "SOFTBUS_SESSION_ERROR",
+        HiSysEventNameSpace::EventType::FAULT,
+        "MYSESSIONNAME", mySessName,
+        "PEERSESSIONNAME", peerSessName,
+        "PEERDEVID", peerDevId,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportCameraOperaterFail(const std::string& dhId, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "CAMERA_OPERATER_ERROR",
+        HiSysEventNameSpace::EventType::FAULT,
+        "DHID", dhId,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, dhId %s, errMsg %s.", ret, dhId.c_str(), errMsg.c_str());
+    }
+}
+
+void ReportStartVideoEncoderFail(int32_t width, int32_t height, std::string format, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "START_VIDEO_ENCODER_ERROR",
+        HiSysEventNameSpace::EventType::FAULT,
+        "WIDTH", width,
+        "HEIGHT", height,
+        "FORMAT", format,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportStopVideoEncoderFail(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",
+        HiSysEventNameSpace::EventType::FAULT,
+        "WIDTH", width,
+        "HEIGHT", height,
+        "FORMAT", format,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+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 ReportInitSaEvent(int32_t saId, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "INIT_SA_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "SAID", saId,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportReleaseSaEvent(const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "RELEASE_SA_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportLoadHDFEvent(const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "LOAD_HDF_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportUnLoadHDFEvent(const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "UNLOAD_HDF_EVENT",
+        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& devId, const std::string& dhId,
+    std::string version, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "REGIST_CAMERA_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "DEVID", devId,
+        "DHID", dhId,
+        "VERSION", version,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportUnRegisterCameraEvent(const std::string& devId, const std::string& dhId, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "UNREGIST_CAMERA_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "DEVID", devId,
+        "DHID", dhId,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportOpenCameraEvent(const std::string& devId, const std::string& dhId, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "OPEN_CAMERA_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "DEVID", devId,
+        "DHID", dhId,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportCloseCameraEvent(const std::string& devId, const std::string& dhId, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "CLOSE_CAMERA_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "DEVID", devId,
+        "DHID", dhId,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("Write HiSysEvent error, ret:%d, errMsg %s.", ret, errMsg.c_str());
+    }
+}
+
+void ReportConfigStreamsEvent(int32_t streamId, int32_t width, int32_t height, int32_t format,
+    std::string encodeType, std::string streamType, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "CONFIG_STREAMS_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "STREAMID", streamId,
+        "WIDTH", width,
+        "HEIGHT", height,
+        "FORMAT", format,
+        "ENCODETYPE", encodeType,
+        "STREAMTYPE", streamType,
+        "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(int32_t width, int32_t height, int32_t format, std::string isCapture,
+    std::string encodeType, std::string streamType, const std::string& errMsg)
+{
+    int32_t ret = HiSysEventNameSpace::Write(DOMAIN_STR,
+        "START_CAPTURE_EVENT",
+        HiSysEventNameSpace::EventType::BEHAVIOR,
+        "WIDTH", width,
+        "HEIGHT", height,
+        "FORMAT", format,
+        "ISCAPTURE", isCapture,
+        "ENCODETYPE", encodeType,
+        "STREAMTYPE", streamType,
+        "MSG", errMsg);
+    if (ret != DCAMERA_OK) {
+        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
\ No newline at end of file
diff --git a/hisysevent.yaml b/hisysevent.yaml
index 50b9577..825137a 100644
--- a/hisysevent.yaml
+++ b/hisysevent.yaml
@@ -41,34 +41,28 @@ domain: DISTCAMERA
 
 SA_ERROR:
   __BASE: {type: FAULT, level: CRITICAL, desc: dcamera sa error occured}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
   MSG: {type: STRING, desc: dcamera hdf error info}
 
-REGISTER_ERROR:
+REGISTER_HARDWARE_ERROR:
   __BASE: {type: FAULT, level: CRITICAL, desc: register dcamera error occured}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
   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}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
   MYSESSIONNAME: {type: STRING, desc: softbus my session name}
   PEERSESSIONNAME: {type: STRING, desc: softbus peer session name}
   PEERDEVID: {type: STRING, desc: peer network id}
@@ -76,90 +70,99 @@ SOFTBUS_SESSION_ERROR:
 
 CAMERA_OPERATER_ERROR:
   __BASE: {type: FAULT, level: CRITICAL, desc: dcamera operater error occured}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  DHID: {type: STRING, desc: dcamera dhId}
   MSG: {type: STRING, desc: dcamera operater error info}
 
-VIDEO_ENCODER_ERROR:
+START_VIDEO_ENCODER_ERROR:
   __BASE: {type: FAULT, level: CRITICAL, desc: video encoder error occured}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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}
 
-VIDEO_DECODER_ERROR:
+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}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera init sa event}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  SAID: {type: INT32, desc: dcamera SAID}
   MSG: {type: STRING, desc: dcamera init sa event}
 
 RELEASE_SA_EVENT:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera release sa event}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
   MSG: {type: STRING, desc: dcamera release sa event}
 
 LOAD_HDF_EVENT:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera load hdf event}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
   MSG: {type: STRING, desc: dcamera load hdf event}
 
 UNLOAD_HDF_EVENT:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera unload hdf event}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
   MSG: {type: STRING, desc: dcamera unload hdf event}
 
 REGIST_CAMERA_EVENT:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera register event}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera unregister event}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  DEVID: {type: STRING, desc: dcamera devId}
+  DHID: {type: STRING, desc: dcamera dhId}
   MSG: {type: STRING, desc: dcamera unregister event}
  
 OPEN_CAMERA_EVENT:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera open event}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  DEVID: {type: STRING, desc: dcamera devId}
+  DHID: {type: STRING, desc: dcamera dhId}
   MSG: {type: STRING, desc: dcamera open event}
 
 CLOSE_CAMERA_EVENT:
   __BASE: {type: BEHAVIOR, level: MINOR, desc: dcamera close event}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  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}
-  PID: {type: INT32, desc: dcamera pid}
-  UID: {type: INT32, desc: dcamera uid}
+  STREAMID: {type: INT32, desc: dcamera streamId}
   MSG: {type: STRING, desc: dcamera stop capture event}
diff --git a/interfaces/inner_kits/native_cpp/camera_sink/BUILD.gn b/interfaces/inner_kits/native_cpp/camera_sink/BUILD.gn
index c750d3b..2dddd28 100644
--- a/interfaces/inner_kits/native_cpp/camera_sink/BUILD.gn
+++ b/interfaces/inner_kits/native_cpp/camera_sink/BUILD.gn
@@ -28,6 +28,7 @@ ohos_shared_library("distributed_camera_sink_sdk") {
   include_dirs += [
     "include",
     "${common_path}/include/constants",
+    "${common_path}/include/utils",
   ]
 
   sources = [
@@ -38,6 +39,7 @@ ohos_shared_library("distributed_camera_sink_sdk") {
   ]
 
   deps = [
+    "${common_path}:distributed_camera_utils",
     "${fwk_utils_path}:distributedhardwareutils",
     "//utils/native/base:utils",
   ]
@@ -49,7 +51,6 @@ ohos_shared_library("distributed_camera_sink_sdk") {
   ]
 
   external_deps = [
-    "hisysevent_native:libhisysevent",
     "hiviewdfx_hilog_native:libhilog",
     "ipc:ipc_core",
     "samgr_standard:samgr_proxy",
diff --git a/interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_handler.cpp b/interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_handler.cpp
index acad610..5fca8cd 100644
--- a/interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_handler.cpp
+++ b/interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_handler.cpp
@@ -15,10 +15,8 @@
 
 #include "dcamera_sink_handler.h"
 
-#include <unistd.h>
-
 #include "anonymous_string.h"
-#include "hisysevent.h"
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_sink_handler_ipc.h"
 #include "dcamera_sink_load_callback.h"
 #include "distributed_camera_constants.h"
@@ -44,16 +42,7 @@ int32_t DCameraSinkHandler::InitSink(const std::string& params)
         DHLOGE("GetSourceLocalDHMS GetSystemAbilityManager failed");
         return DCAMERA_INIT_ERR;
     }
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "INIT_SA_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "init sink sa event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportInitSaEvent(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) {
@@ -104,17 +93,7 @@ int32_t DCameraSinkHandler::ReleaseSink()
         return DCAMERA_BAD_VALUE;
     }
 
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "RELEASE_SA_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "release sink sa event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
-
+    ReportReleaseSaEvent("release sink sa event.");
     int32_t ret = dCameraSinkSrv->ReleaseSink();
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSinkHandler::ReleaseSink sink service release failed, ret: %d", ret);
diff --git a/interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_load_callback.cpp b/interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_load_callback.cpp
index b31ec30..a3a8de7 100644
--- a/interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_load_callback.cpp
+++ b/interfaces/inner_kits/native_cpp/camera_sink/src/dcamera_sink_load_callback.cpp
@@ -15,11 +15,10 @@
 
 #include "dcamera_sink_load_callback.h"
 
-#include "hisysevent.h"
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_sink_handler.h"
 #include "distributed_hardware_log.h"
 #include "distributed_camera_constants.h"
-#include "distributed_camera_errno.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -45,16 +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!");
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "SA_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "dcamera sink OnLoadSystemAbilityFail.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
+        ReportLoadSaFail(systemAbilityId, "dcamera sink OnLoadSystemAbilityFail.");
         return;
     }
     DCameraSinkHandler::GetInstance().FinishStartSAFailed(systemAbilityId);
diff --git a/interfaces/inner_kits/native_cpp/camera_source/BUILD.gn b/interfaces/inner_kits/native_cpp/camera_source/BUILD.gn
index 10a86c2..93660d6 100644
--- a/interfaces/inner_kits/native_cpp/camera_source/BUILD.gn
+++ b/interfaces/inner_kits/native_cpp/camera_source/BUILD.gn
@@ -29,6 +29,7 @@ ohos_shared_library("distributed_camera_source_sdk") {
     "include",
     "include/callback",
     "${common_path}/include/constants",
+    "${common_path}/include/utils",
   ]
 
   sources = [
@@ -41,6 +42,7 @@ ohos_shared_library("distributed_camera_source_sdk") {
   ]
 
   deps = [
+    "${common_path}:distributed_camera_utils",
     "${fwk_utils_path}:distributedhardwareutils",
     "//utils/native/base:utils",
   ]
@@ -52,7 +54,6 @@ ohos_shared_library("distributed_camera_source_sdk") {
   ]
 
   external_deps = [
-    "hisysevent_native:libhisysevent",
     "hiviewdfx_hilog_native:libhilog",
     "ipc:ipc_core",
     "samgr_standard:samgr_proxy",
diff --git a/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp
index 2819862..2b29c89 100644
--- a/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp
+++ b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp
@@ -15,10 +15,8 @@
 
 #include "dcamera_source_handler.h"
 
-#include <unistd.h>
-
 #include "anonymous_string.h"
-#include "hisysevent.h"
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_source_callback.h"
 #include "dcamera_source_handler_ipc.h"
 #include "dcamera_source_load_callback.h"
@@ -46,16 +44,7 @@ int32_t DCameraSourceHandler::InitSource(const std::string& params)
         DHLOGE("GetSourceLocalDHMS GetSystemAbilityManager failed");
         return DCAMERA_INIT_ERR;
     }
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "INIT_SA_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "init source sa event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportInitSaEvent(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) {
@@ -111,16 +100,7 @@ int32_t DCameraSourceHandler::ReleaseSource()
         DHLOGE("DCameraSourceHandler ReleaseSource get Service failed");
         return DCAMERA_INIT_ERR;
     }
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "RELEASE_SA_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "release source sa event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportReleaseSaEvent("release source sa event.");
     dCameraSourceSrv->ReleaseSource();
     DCameraSourceHandlerIpc::GetInstance().UnInit();
     std::unique_lock<std::mutex> lock(producerMutex_);
diff --git a/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_load_callback.cpp b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_load_callback.cpp
index 2664978..b527558 100644
--- a/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_load_callback.cpp
+++ b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_load_callback.cpp
@@ -15,11 +15,10 @@
 
 #include "dcamera_source_load_callback.h"
 
-#include "hisysevent.h"
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_source_handler.h"
 #include "distributed_hardware_log.h"
 #include "distributed_camera_constants.h"
-#include "distributed_camera_errno.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -45,16 +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!");
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "SA_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "dcamera source OnLoadSystemAbilityFail.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
+        ReportLoadSaFail(systemAbilityId, "dcamera source OnLoadSystemAbilityFail.");
         return;
     }
     DCameraSourceHandler::GetInstance().FinishStartSAFailed(systemAbilityId);
diff --git a/services/cameraservice/sinkservice/BUILD.gn b/services/cameraservice/sinkservice/BUILD.gn
index a1d5d1a..c3a5fb7 100644
--- a/services/cameraservice/sinkservice/BUILD.gn
+++ b/services/cameraservice/sinkservice/BUILD.gn
@@ -119,7 +119,6 @@ ohos_shared_library("distributed_camera_sink") {
 
   external_deps = [
     "eventhandler:libeventhandler",
-    "hisysevent_native:libhisysevent",
     "hiviewdfx_hilog_native:libhilog",
     "ipc:ipc_core",
     "safwk:system_ability_fwk",
diff --git a/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp b/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp
index 8568795..3065aa9 100644
--- a/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp
+++ b/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp
@@ -15,9 +15,6 @@
 
 #include "distributed_camera_sink_service.h"
 
-#include <unistd.h>
-
-#include "hisysevent.h"
 #include "if_system_ability_manager.h"
 #include "ipc_skeleton.h"
 #include "ipc_types.h"
@@ -27,6 +24,7 @@
 
 #include "anonymous_string.h"
 #include "dcamera_handler.h"
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_sink_service_ipc.h"
 #include "distributed_camera_errno.h"
 #include "distributed_hardware_log.h"
@@ -238,16 +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);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "CAMERA_OPERATER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "sink service open channel failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
+        ReportCameraOperaterFail(dhId, "sink service open channel failed.");
         return ret;
     }
     DHLOGI("DistributedCameraSinkService::OpenChannel success");
diff --git a/services/cameraservice/sourceservice/BUILD.gn b/services/cameraservice/sourceservice/BUILD.gn
index 4d328d0..ad111a6 100644
--- a/services/cameraservice/sourceservice/BUILD.gn
+++ b/services/cameraservice/sourceservice/BUILD.gn
@@ -107,7 +107,6 @@ ohos_shared_library("distributed_camera_source") {
     "device_driver_framework:libhdf_utils",
     "device_driver_framework:libhdi",
     "eventhandler:libeventhandler",
-    "hisysevent_native:libhisysevent",
     "hiviewdfx_hilog_native:libhilog",
     "ipc:ipc_core",
     "safwk:system_ability_fwk",
diff --git a/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp b/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp
index 525446f..94175ff 100644
--- a/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp
@@ -15,9 +15,6 @@
 
 #include "distributed_camera_source_service.h"
 
-#include <unistd.h>
-
-#include "hisysevent.h"
 #include "if_system_ability_manager.h"
 #include "ipc_skeleton.h"
 #include "ipc_types.h"
@@ -27,6 +24,7 @@
 
 #include "anonymous_string.h"
 #include "dcamera_hdf_operate.h"
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_service_state_listener.h"
 #include "dcamera_source_service_ipc.h"
 #include "distributed_camera_errno.h"
@@ -90,16 +88,7 @@ int32_t DistributedCameraSourceService::InitSource(const std::string& params,
     const sptr<IDCameraSourceCallback>& callback)
 {
     DHLOGI("DistributedCameraSourceService InitSource param: %s", params.c_str());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "LOAD_HDF_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "load dcamera hdf event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportLoadHDFEvent("load dcamera hdf event.");
     int32_t ret = LoadDCameraHDF();
     if (ret != DCAMERA_OK) {
         DHLOGE("DistributedCameraSourceService InitSource LoadHDF failed, ret: %d", ret);
@@ -113,16 +102,7 @@ int32_t DistributedCameraSourceService::InitSource(const std::string& params,
 int32_t DistributedCameraSourceService::ReleaseSource()
 {
     DHLOGI("DistributedCameraSourceService ReleaseSource");
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "UNLOAD_HDF_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "unload dcamera hdf event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportUnLoadHDFEvent("unload dcamera hdf event.");
     int32_t ret = UnLoadCameraHDF();
     if (ret != DCAMERA_OK) {
         DHLOGE("DistributedCameraSourceService ReleaseSource UnLoadHDF failed, ret: %d", ret);
@@ -165,17 +145,9 @@ 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,
+            "dcamera source RegisterDistributedHardware fail.");
         camerasMap_.erase(camIndex);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "REGISTER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "dcamera source RegisterDistributedHardware fail.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
     }
     DHLOGI("DistributedCameraSourceService RegisterDistributedHardware end devId: %s, dhId: %s, version: %s",
         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), param.version.c_str());
@@ -228,16 +200,7 @@ int32_t DistributedCameraSourceService::LoadDCameraHDF()
     int32_t ret = DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl();
     if (ret != DCAMERA_OK) {
         DHLOGE("load hdf driver failed, ret %d", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "HDF_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "dcamera load hdf driver fail.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
+        ReportHDFFail("dcamera load hdf driver fail.");
         return ret;
     }
     DHLOGI("load hdf driver end");
@@ -250,16 +213,7 @@ int32_t DistributedCameraSourceService::UnLoadCameraHDF()
     int32_t ret = DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl();
     if (ret != DCAMERA_OK) {
         DHLOGE("unload hdf driver failed, ret %d", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "HDF_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "dcamera unload hdf driver fail.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
+        ReportHDFFail("dcamera unload hdf driver fail.");
         return ret;
     }
     DHLOGI("unload hdf driver end");
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
index d386373..bfd7625 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
@@ -16,7 +16,7 @@
 #include "dcamera_source_dev.h"
 
 #include "anonymous_string.h"
-#include "hisysevent.h"
+#include "dcamera_hisysevent_adapter.h"
 #include "distributed_camera_constants.h"
 #include "distributed_camera_errno.h"
 #include "distributed_hardware_log.h"
@@ -30,6 +30,13 @@
 
 namespace OHOS {
 namespace DistributedHardware {
+const string ENUM_STREAMTYPE_STRINGS[] = {
+    "CONTINUOUS_FRAME", "SNAPSHOT_FRAME"
+};
+const string ENUM_ENCODETYPE_STRINGS[] = {
+    "ENCODE_TYPE_NULL", "ENCODE_TYPE_H264", "ENCODE_TYPE_H265", "ENCODE_TYPE_JPEG"
+};
+
 DCameraSourceDev::DCameraSourceDev(std::string devId, std::string dhId,
     std::shared_ptr<ICameraStateListener>& stateLisener) : devId_(devId), dhId_(dhId), stateListener_(stateLisener)
 {
@@ -216,16 +223,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());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "REGIST_CAMERA_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "execute register event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportRegisterCameraEvent(GetAnonyString(devId_), dhId_, version_, "execute register event.");
     std::vector<DCameraIndex> actualDevInfo;
     actualDevInfo.assign(actualDevInfo_.begin(), actualDevInfo_.end());
     int32_t ret = controller_->Init(actualDevInfo);
@@ -269,16 +267,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());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "UNREGIST_CAMERA_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "execute unregister event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportUnRegisterCameraEvent(GetAnonyString(devId_), dhId_, "execute unregister event.");
     int32_t ret = controller_->UnInit();
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceDev Execute UnRegister controller uninit failed, ret: %d, devId: %s dhId: %s", ret,
@@ -314,16 +303,7 @@ int32_t DCameraSourceDev::ExecuteOpenCamera()
 {
     DHLOGI("DCameraSourceDev Execute OpenCamera devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "OPEN_CAMERA_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "execute open camera event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportOpenCameraEvent(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) {
@@ -345,16 +325,7 @@ int32_t DCameraSourceDev::ExecuteCloseCamera()
 {
     DHLOGI("DCameraSourceDev Execute CloseCamera devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "CLOSE_CAMERA_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "execute close camera event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
+    ReportCloseCameraEvent(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,
@@ -372,15 +343,11 @@ 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());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "CONFIG_STREAMS_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "execute config streams event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
+    for (auto iter = streamInfos.begin(); iter != streamInfos.end(); iter++) {
+        std::shared_ptr<DCStreamInfo> streamInfo = *iter;
+        ReportConfigStreamsEvent(streamInfo->streamId_, streamInfo->width_, streamInfo->height_, streamInfo->format_,
+            ENUM_ENCODETYPE_STRINGS[streamInfo->encodeType_], ENUM_STREAMTYPE_STRINGS[streamInfo->type_],
+            "execute config streams event.");
     }
     int32_t ret = input_->ConfigStreams(streamInfos);
     if (ret != DCAMERA_OK) {
@@ -423,15 +390,8 @@ 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());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "RELEASE_STREAMS_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "execute release streams event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
+    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) {
@@ -459,16 +419,6 @@ int32_t DCameraSourceDev::ExecuteStartCapture(std::vector<std::shared_ptr<DCCapt
 {
     DHLOGI("DCameraSourceDev Execute StartCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "START_CAPTURE_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "execute start capture event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
     int32_t ret = input_->StartCapture(captureInfos);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceDev input StartCapture failed ret: %d, devId: %s, dhId: %s", ret,
@@ -489,6 +439,9 @@ int32_t DCameraSourceDev::ExecuteStartCapture(std::vector<std::shared_ptr<DCCapt
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), (*iter)->captureSettings_.size(),
             capture->width_, capture->height_, capture->format_, capture->isCapture_ ? 1 : 0, capture->encodeType_,
             capture->streamType_);
+        ReportStartCaptureEvent(capture->width_, capture->height_, capture->format_,
+            capture->isCapture_ ? "true" : "false", ENUM_ENCODETYPE_STRINGS[capture->encodeType_],
+            ENUM_STREAMTYPE_STRINGS[capture->streamType_], "execute start capture event.");
         for (auto settingIter = (*iter)->captureSettings_.begin(); settingIter != (*iter)->captureSettings_.end();
             settingIter++) {
             std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
@@ -511,15 +464,8 @@ 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());
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "STOP_CAPTURE_EVENT",
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MSG", "execute stop capture event.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
+    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) {
diff --git a/services/channel/BUILD.gn b/services/channel/BUILD.gn
index 963cd15..3e263e0 100644
--- a/services/channel/BUILD.gn
+++ b/services/channel/BUILD.gn
@@ -54,7 +54,6 @@ ohos_shared_library("distributed_camera_channel") {
   external_deps = [
     "dsoftbus_standard:softbus_client",
     "eventhandler:libeventhandler",
-    "hisysevent_native:libhisysevent",
     "hiviewdfx_hilog_native:libhilog",
   ]
 
diff --git a/services/channel/include/dcamera_softbus_adapter.h b/services/channel/include/dcamera_softbus_adapter.h
index 9a4191b..999838f 100644
--- a/services/channel/include/dcamera_softbus_adapter.h
+++ b/services/channel/include/dcamera_softbus_adapter.h
@@ -70,7 +70,6 @@ private:
     int32_t DCameraSoftbusSourceGetSession(int32_t sessionId, std::shared_ptr<DCameraSoftbusSession>& session);
     int32_t DCameraSoftbusSinkGetSession(int32_t sessionId, std::shared_ptr<DCameraSoftbusSession>& session);
     int32_t DCameraSoftbusGetSessionById(int32_t sessionId, std::shared_ptr<DCameraSoftbusSession>& session);
-    void ReportSoftbusSessionFail(std::string mySessName, std::string peerSessName, std::string peerDevId);
 
 private:
     std::mutex optLock_;
diff --git a/services/channel/src/dcamera_softbus_adapter.cpp b/services/channel/src/dcamera_softbus_adapter.cpp
index be63b93..212db47 100644
--- a/services/channel/src/dcamera_softbus_adapter.cpp
+++ b/services/channel/src/dcamera_softbus_adapter.cpp
@@ -15,14 +15,13 @@
 
 #include "dcamera_softbus_adapter.h"
 
-#include <unistd.h>
 #include <securec.h>
 
-#include "hisysevent.h"
 #include "softbus_bus_center.h"
 #include "softbus_common.h"
 
 #include "anonymous_string.h"
+#include "dcamera_hisysevent_adapter.h"
 #include "distributed_camera_constants.h"
 #include "distributed_camera_errno.h"
 #include "distributed_hardware_log.h"
@@ -127,18 +126,7 @@ 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);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "SOFTBUS_SESSIONSERVER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "PKGNAME", PKG_NAME.c_str(),
-            "SESSIONNAME", sessionName.c_str(),
-            "MSG", "create session server failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
+        ReportSoftbusSessionServerFail(PKG_NAME, sessionName, "create session server failed");
         return ret;
     }
     sessionTotal_[sessionName]++;
@@ -211,30 +199,12 @@ 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);
+        ReportSoftbusSessionFail(mySessName, peerSessName, peerDevId, "open softbus session failed.");
         return DCAMERA_BAD_OPERATE;
     }
     return DCAMERA_OK;
 }
 
-void DCameraSoftbusAdapter::ReportSoftbusSessionFail(std::string mySessName,
-    std::string peerSessName, std::string peerDevId)
-{
-    int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-        OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-        "SOFTBUS_SESSION_ERROR",
-        OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-        "PID", getpid(),
-        "UID", getuid(),
-        "MYSESSIONNAME", mySessName.c_str(),
-        "PEERSESSIONNAME", peerSessName.c_str(),
-        "PEERDEVID", peerDevId.c_str(),
-        "MSG", "open softbus session failed.");
-    if (retVal != DCAMERA_OK) {
-        DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-    }
-}
-
 int32_t DCameraSoftbusAdapter::CloseSoftbusSession(int32_t sessionId)
 {
     DHLOGI("close softbus sessionId: %d", sessionId);
diff --git a/services/data_process/BUILD.gn b/services/data_process/BUILD.gn
index 3dfa78a..9197293 100644
--- a/services/data_process/BUILD.gn
+++ b/services/data_process/BUILD.gn
@@ -84,7 +84,6 @@ ohos_shared_library("distributed_camera_data_process") {
 
   external_deps = [
     "eventhandler:libeventhandler",
-    "hisysevent_native:libhisysevent",
     "hiviewdfx_hilog_native:libhilog",
     "multimedia_media_standard:media_client",
   ]
diff --git a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp
index 118f83b..0493184 100644
--- a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp
+++ b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp
@@ -15,16 +15,20 @@
 
 #include "decode_data_process.h"
 
-#include "hisysevent.h"
 #include "distributed_hardware_log.h"
 #include "graphic_common_c.h"
 
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_utils_tools.h"
 #include "decode_surface_listener.h"
 #include "decode_video_callback.h"
 
 namespace OHOS {
 namespace DistributedHardware {
+const string ENUM_VIDEOFORMAT_STRINGS[] = {
+    "YUVI420", "NV12", "NV21", "RGBA_8888"
+};
+
 DecodeDataProcess::~DecodeDataProcess()
 {
     if (isDecoderProcess_.load()) {
@@ -107,6 +111,9 @@ int32_t DecodeDataProcess::InitDecoder()
     ret = StartVideoDecoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("Start Video decoder failed.");
+        ReportStartVideoDecoderFail(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
+            ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())],
+            "start video decoder failed.");
         return ret;
     }
     return DCAMERA_OK;
@@ -233,16 +240,6 @@ int32_t DecodeDataProcess::StartVideoDecoder()
     ret = videoDecoder_->Start();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {
         DHLOGE("Video decoder start failed. Error code %d.", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "VIDEO_DECODER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "video decoder start failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
         return DCAMERA_INIT_ERR;
     }
     return DCAMERA_OK;
@@ -264,16 +261,6 @@ int32_t DecodeDataProcess::StopVideoDecoder()
     ret = videoDecoder_->Stop();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {
         DHLOGE("VideoDecoder stop failed. Error type: %d.", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "VIDEO_DECODER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "video decoder stop failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
         isSuccess = isSuccess && false;
     }
     if (!isSuccess) {
@@ -294,6 +281,7 @@ 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) {
diff --git a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp
index dacc723..3db9cd5 100644
--- a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp
+++ b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp
@@ -15,16 +15,20 @@
 
 #include "decode_data_process.h"
 
-#include "hisysevent.h"
 #include "distributed_hardware_log.h"
 #include "graphic_common_c.h"
 
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_utils_tools.h"
 #include "decode_surface_listener.h"
 #include "decode_video_callback.h"
 
 namespace OHOS {
 namespace DistributedHardware {
+const string ENUM_VIDEOFORMAT_STRINGS[] = {
+    "YUVI420", "NV12", "NV21", "RGBA_8888"
+};
+
 DecodeDataProcess::~DecodeDataProcess()
 {
     if (isDecoderProcess_.load()) {
@@ -107,6 +111,9 @@ int32_t DecodeDataProcess::InitDecoder()
     ret = StartVideoDecoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("Start Video decoder failed.");
+        ReportStartVideoDecoderFail(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
+            ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())],
+            "start video decoder failed.");
         return ret;
     }
     return DCAMERA_OK;
@@ -221,16 +228,6 @@ int32_t DecodeDataProcess::StartVideoDecoder()
     ret = videoDecoder_->Start();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {
         DHLOGE("Video decoder start failed. Error code %d.", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "VIDEO_DECODER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "video decoder start failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
         return DCAMERA_INIT_ERR;
     }
     return DCAMERA_OK;
@@ -253,16 +250,6 @@ int32_t DecodeDataProcess::StopVideoDecoder()
     ret = videoDecoder_->Stop();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {
         DHLOGE("VideoDecoder stop failed. Error type: %d.", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "VIDEO_DECODER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "video decoder stop failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
         isSuccess = isSuccess && false;
     }
     if (!isSuccess) {
@@ -283,6 +270,7 @@ 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) {
diff --git a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
index 8a97cf6..5e999c6 100644
--- a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
+++ b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
@@ -16,13 +16,12 @@
 #include "encode_data_process.h"
 
 #include <cmath>
-#include <unistd.h>
 
-#include "hisysevent.h"
 #include "display_type.h"
 #include "distributed_hardware_log.h"
 #include "graphic_common_c.h"
 
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_utils_tools.h"
 #include "encode_video_callback.h"
 
@@ -44,6 +43,9 @@ const std::map<int64_t, int32_t> EncodeDataProcess::ENCODER_BITRATE_TABLE = {
     std::map<int64_t, int32_t>::value_type(WIDTH_1440_HEIGHT_1080, BITRATE_5000000),
     std::map<int64_t, int32_t>::value_type(WIDTH_1920_HEIGHT_1080, BITRATE_6000000),
 };
+const string ENUM_VIDEOFORMAT_STRINGS[] = {
+    "YUVI420", "NV12", "NV21", "RGBA_8888"
+};
 
 EncodeDataProcess::~EncodeDataProcess()
 {
@@ -114,6 +116,9 @@ int32_t EncodeDataProcess::InitEncoder()
     ret = StartVideoEncoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("Start Video encoder failed.");
+        ReportStartVideoEncoderFail(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
+            ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())],
+            "start video encoder failed.");
         return ret;
     }
 
@@ -257,16 +262,6 @@ int32_t EncodeDataProcess::StartVideoEncoder()
     ret = videoEncoder_->Start();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {
         DHLOGE("Video encoder start failed. Error code %d.", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "VIDEO_ENCODER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "video encoder start failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
         return DCAMERA_INIT_ERR;
     }
     return DCAMERA_OK;
@@ -288,16 +283,6 @@ int32_t EncodeDataProcess::StopVideoEncoder()
     ret = videoEncoder_->Stop();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {
         DHLOGE("VideoEncoder stop failed. Error type: %d.", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "VIDEO_ENCODER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "video encoder stop failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
         isSuccess = isSuccess && false;
     }
 
@@ -321,6 +306,7 @@ 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) {
diff --git a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process_common.cpp b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process_common.cpp
index ea82476..e8b5e5b 100644
--- a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process_common.cpp
+++ b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process_common.cpp
@@ -16,13 +16,12 @@
 #include "encode_data_process.h"
 
 #include <cmath>
-#include <unistd.h>
 
 #include "display_type.h"
 #include "distributed_hardware_log.h"
 #include "graphic_common_c.h"
-#include "hisysevent.h"
 
+#include "dcamera_hisysevent_adapter.h"
 #include "dcamera_utils_tools.h"
 #include "encode_video_callback.h"
 
@@ -44,6 +43,9 @@ const std::map<int64_t, int32_t> EncodeDataProcess::ENCODER_BITRATE_TABLE = {
     std::map<int64_t, int32_t>::value_type(WIDTH_1440_HEIGHT_1080, BITRATE_5000000),
     std::map<int64_t, int32_t>::value_type(WIDTH_1920_HEIGHT_1080, BITRATE_6000000),
 };
+const string ENUM_VIDEOFORMAT_STRINGS[] = {
+    "YUVI420", "NV12", "NV21", "RGBA_8888"
+};
 
 EncodeDataProcess::~EncodeDataProcess()
 {
@@ -114,6 +116,9 @@ int32_t EncodeDataProcess::InitEncoder()
     ret = StartVideoEncoder();
     if (ret != DCAMERA_OK) {
         DHLOGE("Start Video encoder failed.");
+        ReportStartVideoEncoderFail(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
+            ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())],
+            "start video encoder failed.");
         return ret;
     }
 
@@ -229,16 +234,6 @@ int32_t EncodeDataProcess::StartVideoEncoder()
     ret = videoEncoder_->Start();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {
         DHLOGE("Video encoder start failed. Error code %d.", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "VIDEO_ENCODER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "video encoder start failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
         return DCAMERA_INIT_ERR;
     }
     return DCAMERA_OK;
@@ -260,16 +255,6 @@ int32_t EncodeDataProcess::StopVideoEncoder()
     ret = videoEncoder_->Stop();
     if (ret != Media::MediaServiceErrCode::MSERR_OK) {
         DHLOGE("VideoEncoder stop failed. Error type: %d.", ret);
-        int32_t retVal = OHOS::HiviewDFX::HiSysEvent::Write(
-            OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_CAMERA,
-            "VIDEO_ENCODER_ERROR",
-            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
-            "PID", getpid(),
-            "UID", getuid(),
-            "MSG", "video encoder stop failed.");
-        if (retVal != DCAMERA_OK) {
-            DHLOGE("Write HiSysEvent error, retVal:%d", retVal);
-        }
         isSuccess = isSuccess && false;
     }
 
@@ -293,6 +278,7 @@ 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) {