diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h
index df23f5c50b8ff30f97b3a9329614cfa70ea10f65..e7fe9bc25b0c64e127fd19f3562f5be67960e4e9 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h
@@ -54,18 +54,18 @@ public:
     std::string GetVersion();
 
 public:
-    virtual int32_t ExecuteRegister(std::shared_ptr<DCameraRegistParam>& param);
-    virtual int32_t ExecuteUnRegister(std::shared_ptr<DCameraRegistParam>& param);
-    virtual int32_t ExecuteOpenCamera();
-    virtual int32_t ExecuteCloseCamera();
-    virtual int32_t ExecuteConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos);
-    virtual int32_t ExecuteReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease);
-    virtual int32_t ExecuteReleaseAllStreams();
-    virtual int32_t ExecuteStartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos);
-    virtual int32_t ExecuteStopCapture(std::vector<int>& streamIds, bool& isAllStop);
-    virtual int32_t ExecuteStopAllCapture();
-    virtual int32_t ExecuteUpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings);
-    virtual int32_t ExecuteCameraEventNotify(std::shared_ptr<DCameraEvent>& events);
+    virtual int32_t Register(std::shared_ptr<DCameraRegistParam>& param);
+    virtual int32_t UnRegister(std::shared_ptr<DCameraRegistParam>& param);
+    virtual int32_t OpenCamera();
+    virtual int32_t CloseCamera();
+    virtual int32_t ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos);
+    virtual int32_t ReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease);
+    virtual int32_t ReleaseAllStreams();
+    virtual int32_t StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos);
+    virtual int32_t StopCapture(std::vector<int>& streamIds, bool& isAllStop);
+    virtual int32_t StopAllCapture();
+    virtual int32_t UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings);
+    virtual int32_t CameraEventNotify(std::shared_ptr<DCameraEvent>& events);
 
 private:
     using DCameraNotifyFunc = void (DCameraSourceDev::*)(DCAMERA_EVENT eventType, DCameraSourceEvent& event,
@@ -73,7 +73,6 @@ private:
 
     void NotifyResult(DCAMERA_EVENT eventType, DCameraSourceEvent& event, int32_t result);
     void NotifyRegisterResult(DCAMERA_EVENT eventType, DCameraSourceEvent& event, int32_t result);
-    void NotifyUnregisterResult(DCAMERA_EVENT eventType, DCameraSourceEvent& event, int32_t result);
     void NotifyHalResult(DCAMERA_EVENT eventType, DCameraSourceEvent& event, int32_t result);
     void HitraceAndHisyseventImpl(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos);
 
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_event.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_event.h
index f0d15aa1111f7bf71f4acb9b4b7c7ebc89bd0e0b..18c0f3c1c810cf835b03e8b45b0bc786941734e6 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_event.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_event.h
@@ -113,9 +113,13 @@ public:
     DCAMERA_EVENT GetEventType();
 
 private:
-    using EventParam = std::variant<std::monostate, DCameraIndex, std::shared_ptr<DCameraRegistParam>,
-        std::vector<std::shared_ptr<DCStreamInfo>>, std::vector<std::shared_ptr<DCCaptureInfo>>,
-        std::vector<std::shared_ptr<DCameraSettings>>, std::vector<int>, std::shared_ptr<DCameraEvent>>;
+    using EventParam = std::variant<std::monostate,
+        DCameraIndex,
+        std::shared_ptr<DCameraRegistParam>,
+        std::vector<std::shared_ptr<DCStreamInfo>>,
+        std::vector<std::shared_ptr<DCCaptureInfo>>,
+        std::vector<std::shared_ptr<DCameraSettings>>,
+        std::vector<int>, std::shared_ptr<DCameraEvent>>;
 
 private:
     DCAMERA_EVENT eventType_;
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
index 8da11cc3b7adf000d0ad878b23411bc7b843923d..2d480bd24467b06ea6bd8b6a55c7fbd9a552c166 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
@@ -37,7 +37,7 @@ DCameraSourceDev::DCameraSourceDev(std::string devId, std::string dhId,
     DHLOGI("DCameraSourceDev Construct devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
     memberFuncMap_[DCAMERA_EVENT_REGIST] = &DCameraSourceDev::NotifyRegisterResult;
-    memberFuncMap_[DCAMERA_EVENT_UNREGIST] = &DCameraSourceDev::NotifyUnregisterResult;
+    memberFuncMap_[DCAMERA_EVENT_UNREGIST] = &DCameraSourceDev::NotifyRegisterResult;
     memberFuncMap_[DCAMERA_EVENT_OPEN] = &DCameraSourceDev::NotifyHalResult;
     memberFuncMap_[DCAMERA_EVENT_CLOSE] = &DCameraSourceDev::NotifyHalResult;
     memberFuncMap_[DCAMERA_EVENT_CONFIG_STREAMS] = &DCameraSourceDev::NotifyHalResult;
@@ -213,7 +213,7 @@ void DCameraSourceDev::OnEvent(DCameraSourceEvent& event)
     NotifyResult(event.GetEventType(), event, ret);
 }
 
-int32_t DCameraSourceDev::ExecuteRegister(std::shared_ptr<DCameraRegistParam>& param)
+int32_t DCameraSourceDev::Register(std::shared_ptr<DCameraRegistParam>& param)
 {
     DCAMERA_SYNC_TRACE(DCAMERA_REGISTER_CAMERA);
     DHLOGI("DCameraSourceDev Execute Register devId: %s dhId: %s",
@@ -239,7 +239,7 @@ int32_t DCameraSourceDev::ExecuteRegister(std::shared_ptr<DCameraRegistParam>& p
 
     sptr<IDCameraProvider> camHdiProvider = IDCameraProvider::Get(HDF_DCAMERA_EXT_SERVICE);
     if (camHdiProvider == nullptr) {
-        DHLOGI("ExecuteRegister camHdiProvider is nullptr devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
+        DHLOGI("Register camHdiProvider is nullptr devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
             GetAnonyString(dhId_).c_str());
         controller_->UnInit();
         input_->UnInit();
@@ -259,7 +259,7 @@ int32_t DCameraSourceDev::ExecuteRegister(std::shared_ptr<DCameraRegistParam>& p
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteUnRegister(std::shared_ptr<DCameraRegistParam>& param)
+int32_t DCameraSourceDev::UnRegister(std::shared_ptr<DCameraRegistParam>& param)
 {
     DCAMERA_SYNC_TRACE(DCAMERA_UNREGISTER_CAMERA);
     DHLOGI("DCameraSourceDev Execute UnRegister devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
@@ -280,7 +280,7 @@ int32_t DCameraSourceDev::ExecuteUnRegister(std::shared_ptr<DCameraRegistParam>&
 
     sptr<IDCameraProvider> camHdiProvider = IDCameraProvider::Get(HDF_DCAMERA_EXT_SERVICE);
     if (camHdiProvider == nullptr) {
-        DHLOGI("ExecuteUnRegister camHdiProvider is nullptr devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
+        DHLOGI("UnRegister camHdiProvider is nullptr devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
             GetAnonyString(dhId_).c_str());
         return DCAMERA_BAD_OPERATE;
     }
@@ -297,7 +297,7 @@ int32_t DCameraSourceDev::ExecuteUnRegister(std::shared_ptr<DCameraRegistParam>&
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteOpenCamera()
+int32_t DCameraSourceDev::OpenCamera()
 {
     DHLOGI("DCameraSourceDev Execute OpenCamera devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -321,7 +321,7 @@ int32_t DCameraSourceDev::ExecuteOpenCamera()
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteCloseCamera()
+int32_t DCameraSourceDev::CloseCamera()
 {
     DHLOGI("DCameraSourceDev Execute CloseCamera devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -339,7 +339,7 @@ int32_t DCameraSourceDev::ExecuteCloseCamera()
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos)
+int32_t DCameraSourceDev::ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos)
 {
     DHLOGI("DCameraSourceDev Execute ConfigStreams devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -380,7 +380,7 @@ int32_t DCameraSourceDev::ExecuteConfigStreams(std::vector<std::shared_ptr<DCStr
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease)
+int32_t DCameraSourceDev::ReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease)
 {
     DHLOGI("DCameraSourceDev Execute ReleaseStreams devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -393,7 +393,7 @@ int32_t DCameraSourceDev::ExecuteReleaseStreams(std::vector<int>& streamIds, boo
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteReleaseAllStreams()
+int32_t DCameraSourceDev::ReleaseAllStreams()
 {
     DHLOGI("DCameraSourceDev Execute ReleaseAllStreams devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -406,7 +406,7 @@ int32_t DCameraSourceDev::ExecuteReleaseAllStreams()
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteStartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos)
+int32_t DCameraSourceDev::StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos)
 {
     HitraceAndHisyseventImpl(captureInfos);
     DHLOGI("DCameraSourceDev Execute StartCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
@@ -429,7 +429,7 @@ int32_t DCameraSourceDev::ExecuteStartCapture(std::vector<std::shared_ptr<DCCapt
         capture->isCapture_ = (*iter)->isCapture_;
         capture->encodeType_ = (*iter)->encodeType_;
         capture->streamType_ = (*iter)->type_;
-        DHLOGI("ExecuteStartCapture devId %s dhId %s settings size: %d w: %d h: %d fmt: %d isC: %d enc: %d streamT: %d",
+        DHLOGI("StartCapture devId %s dhId %s settings size: %d w: %d h: %d fmt: %d isC: %d enc: %d streamT: %d",
             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_);
@@ -474,7 +474,7 @@ void DCameraSourceDev::HitraceAndHisyseventImpl(std::vector<std::shared_ptr<DCCa
     }
 }
 
-int32_t DCameraSourceDev::ExecuteStopCapture(std::vector<int>& streamIds, bool& isAllStop)
+int32_t DCameraSourceDev::StopCapture(std::vector<int>& streamIds, bool& isAllStop)
 {
     DHLOGI("DCameraSourceDev Execute StopCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -493,7 +493,7 @@ int32_t DCameraSourceDev::ExecuteStopCapture(std::vector<int>& streamIds, bool&
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteStopAllCapture()
+int32_t DCameraSourceDev::StopAllCapture()
 {
     DHLOGI("DCameraSourceDev Execute StopAllCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -510,7 +510,7 @@ int32_t DCameraSourceDev::ExecuteStopAllCapture()
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteUpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
+int32_t DCameraSourceDev::UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
 {
     DHLOGI("DCameraSourceDev Execute UpdateSettings devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -529,7 +529,7 @@ int32_t DCameraSourceDev::ExecuteUpdateSettings(std::vector<std::shared_ptr<DCam
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::ExecuteCameraEventNotify(std::shared_ptr<DCameraEvent>& events)
+int32_t DCameraSourceDev::CameraEventNotify(std::shared_ptr<DCameraEvent>& events)
 {
     DHLOGI("DCameraSourceDev Execute CameraEventNotify devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -569,23 +569,11 @@ void DCameraSourceDev::NotifyRegisterResult(DCAMERA_EVENT eventType, DCameraSour
         DHLOGE("DCameraSourceDev can not get listener");
         return;
     }
-    stateListener_->OnRegisterNotify(param->devId_, param->dhId_, param->reqId_, result, data);
-}
-
-void DCameraSourceDev::NotifyUnregisterResult(DCAMERA_EVENT eventType, DCameraSourceEvent& event, int32_t result)
-{
-    std::string data = "";
-    std::shared_ptr<DCameraRegistParam> param;
-    int32_t ret = event.GetDCameraRegistParam(param);
-    if (ret != DCAMERA_OK) {
-        return;
-    }
-
-    if (stateListener_ == nullptr) {
-        DHLOGE("DCameraSourceDev can not get listener");
-        return;
+    if (eventType == DCAMERA_EVENT_REGIST) {
+        stateListener_->OnRegisterNotify(param->devId_, param->dhId_, param->reqId_, result, data);
+    } else {
+        stateListener_->OnUnregisterNotify(param->devId_, param->dhId_, param->reqId_, result, data);
     }
-    stateListener_->OnUnregisterNotify(param->devId_, param->dhId_, param->reqId_, result, data);
 }
 
 void DCameraSourceDev::NotifyHalResult(DCAMERA_EVENT eventType, DCameraSourceEvent& event, int32_t result)
@@ -603,7 +591,7 @@ void DCameraSourceDev::NotifyHalResult(DCAMERA_EVENT eventType, DCameraSourceEve
         return;
     }
     events->eventResult_ = iter->second;
-    ExecuteCameraEventNotify(events);
+    CameraEventNotify(events);
     return;
 }
 
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_capture_state.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_capture_state.cpp
index cbc7e26c20f5fc8da955c76d64e8c39942318ffe..22881a35f87b6f0e009cd0291907efe58b96f5e4 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_capture_state.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_capture_state.cpp
@@ -69,27 +69,27 @@ int32_t DCameraSourceCaptureState::DoUnregisterTask(std::shared_ptr<DCameraSourc
     std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
     camEvent->eventType_ = DCAMERA_MESSAGE;
     camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
-    int32_t ret = camDev->ExecuteCameraEventNotify(camEvent);
+    int32_t ret = camDev->CameraEventNotify(camEvent);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState DoUnregisterTask ExecuteCameraEventNotify failed: %d", ret);
+        DHLOGE("DCameraSourceCaptureState DoUnregisterTask CameraEventNotify failed: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteStopAllCapture();
+    ret = camDev->StopAllCapture();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState DoUnregisterTask ExecuteStopAllCapture failed: %d", ret);
+        DHLOGE("DCameraSourceCaptureState DoUnregisterTask StopAllCapture failed: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteCloseCamera();
+    ret = camDev->CloseCamera();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState DoUnregisterTask ExecuteCloseCamera failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState DoUnregisterTask CloseCamera failed, ret: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteReleaseAllStreams();
+    ret = camDev->ReleaseAllStreams();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState DoUnregisterTask ExecuteReleaseAllStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState DoUnregisterTask ReleaseAllStreams failed, ret: %d", ret);
         return ret;
     }
 
@@ -98,9 +98,9 @@ int32_t DCameraSourceCaptureState::DoUnregisterTask(std::shared_ptr<DCameraSourc
     if (ret != DCAMERA_OK) {
         return ret;
     }
-    ret = camDev->ExecuteUnRegister(param);
+    ret = camDev->UnRegister(param);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState DoUnregisterTask ExecuteUnRegister failed: %d", ret);
+        DHLOGE("DCameraSourceCaptureState DoUnregisterTask UnRegister failed: %d", ret);
         return ret;
     }
     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
@@ -120,21 +120,21 @@ int32_t DCameraSourceCaptureState::DoOpenTask(std::shared_ptr<DCameraSourceDev>&
 
 int32_t DCameraSourceCaptureState::DoCloseTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
-    int32_t ret = camDev->ExecuteStopAllCapture();
+    int32_t ret = camDev->StopAllCapture();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState ExecuteStopAllCapture failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState StopAllCapture failed, ret: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteReleaseAllStreams();
+    ret = camDev->ReleaseAllStreams();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState ExecuteReleaseAllStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState ReleaseAllStreams failed, ret: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteCloseCamera();
+    ret = camDev->CloseCamera();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState ExecuteCloseCamera failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState CloseCamera failed, ret: %d", ret);
         return ret;
     }
     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
@@ -155,7 +155,7 @@ int32_t DCameraSourceCaptureState::DoStartCaptureTask(std::shared_ptr<DCameraSou
         return ret;
     }
 
-    ret = camDev->ExecuteStartCapture(captureInfos);
+    ret = camDev->StartCapture(captureInfos);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceCaptureState DoStartCaptureTask failed, ret: %d", ret);
         return ret;
@@ -173,9 +173,9 @@ int32_t DCameraSourceCaptureState::DoStopCaptureTask(std::shared_ptr<DCameraSour
     }
 
     bool isAllStop = false;
-    ret = camDev->ExecuteStopCapture(streamIds, isAllStop);
+    ret = camDev->StopCapture(streamIds, isAllStop);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState ExecuteStopCapture failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState StopCapture failed, ret: %d", ret);
         return ret;
     }
 
@@ -199,9 +199,9 @@ int32_t DCameraSourceCaptureState::DoUpdateSettingsTask(std::shared_ptr<DCameraS
         return ret;
     }
 
-    ret = camDev->ExecuteUpdateSettings(settings);
+    ret = camDev->UpdateSettings(settings);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState ExecuteUpdateSettings failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState UpdateSettings failed, ret: %d", ret);
         return ret;
     }
     return DCAMERA_OK;
@@ -216,9 +216,9 @@ int32_t DCameraSourceCaptureState::DoEventNofityTask(std::shared_ptr<DCameraSour
         return ret;
     }
 
-    ret = camDev->ExecuteCameraEventNotify(camEvent);
+    ret = camDev->CameraEventNotify(camEvent);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState ExecuteCameraEventNotify failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState CameraEventNotify failed, ret: %d", ret);
         return ret;
     }
     return DCAMERA_OK;
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_config_stream_state.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_config_stream_state.cpp
index d89768526ba8d135213d2a415dbcb3c51ec009d7..5b710d6789e6c564fc208a68fce712a7cd15dc69 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_config_stream_state.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_config_stream_state.cpp
@@ -72,21 +72,21 @@ int32_t DCameraSourceConfigStreamState::DoUnregisterTask(std::shared_ptr<DCamera
     std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
     camEvent->eventType_ = DCAMERA_MESSAGE;
     camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
-    int32_t ret = camDev->ExecuteCameraEventNotify(camEvent);
+    int32_t ret = camDev->CameraEventNotify(camEvent);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState DoUnregisterTask ExecuteCameraEventNotify failed: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState DoUnregisterTask CameraEventNotify failed: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteCloseCamera();
+    ret = camDev->CloseCamera();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState DoUnregisterTask ExecuteCloseCamera failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState DoUnregisterTask CloseCamera failed, ret: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteReleaseAllStreams();
+    ret = camDev->ReleaseAllStreams();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState DoUnregisterTask ExecuteReleaseAllStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState DoUnregisterTask ReleaseAllStreams failed, ret: %d", ret);
         return ret;
     }
 
@@ -95,9 +95,9 @@ int32_t DCameraSourceConfigStreamState::DoUnregisterTask(std::shared_ptr<DCamera
     if (ret != DCAMERA_OK) {
         return ret;
     }
-    ret = camDev->ExecuteUnRegister(param);
+    ret = camDev->UnRegister(param);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState DoUnregisterTask ExecuteUnRegister failed: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState DoUnregisterTask UnRegister failed: %d", ret);
         return ret;
     }
     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
@@ -118,15 +118,15 @@ int32_t DCameraSourceConfigStreamState::DoOpenTask(std::shared_ptr<DCameraSource
 int32_t DCameraSourceConfigStreamState::DoCloseTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
-    int32_t ret = camDev->ExecuteCloseCamera();
+    int32_t ret = camDev->CloseCamera();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState ExecuteCloseCamera failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState CloseCamera failed, ret: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteReleaseAllStreams();
+    ret = camDev->ReleaseAllStreams();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState ExecuteReleaseAllStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState ReleaseAllStreams failed, ret: %d", ret);
         return ret;
     }
     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
@@ -147,9 +147,9 @@ int32_t DCameraSourceConfigStreamState::DoConfigStreamsTask(std::shared_ptr<DCam
         return ret;
     }
 
-    ret = camDev->ExecuteConfigStreams(streamInfos);
+    ret = camDev->ConfigStreams(streamInfos);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState ExecuteConfigStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState ConfigStreams failed, ret: %d", ret);
         return ret;
     }
 
@@ -174,9 +174,9 @@ int32_t DCameraSourceConfigStreamState::DoReleaseStreamsTask(std::shared_ptr<DCa
     }
 
     bool isAllRelease = false;
-    ret = camDev->ExecuteReleaseStreams(streamIds, isAllRelease);
+    ret = camDev->ReleaseStreams(streamIds, isAllRelease);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState ExecuteConfigStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState ReleaseStreams failed, ret: %d", ret);
         return ret;
     }
 
@@ -200,9 +200,9 @@ int32_t DCameraSourceConfigStreamState::DoStartCaptureTask(std::shared_ptr<DCame
         return ret;
     }
 
-    ret = camDev->ExecuteStartCapture(captureInfos);
+    ret = camDev->StartCapture(captureInfos);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState ExecuteStartCapture failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState StartCapture failed, ret: %d", ret);
         return ret;
     }
     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
@@ -230,9 +230,9 @@ int32_t DCameraSourceConfigStreamState::DoUpdateSettingsTask(std::shared_ptr<DCa
         return ret;
     }
 
-    ret = camDev->ExecuteUpdateSettings(settings);
+    ret = camDev->UpdateSettings(settings);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState ExecuteConfigStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState UpdateSettings failed, ret: %d", ret);
         return ret;
     }
     return DCAMERA_OK;
@@ -247,9 +247,9 @@ int32_t DCameraSourceConfigStreamState::DoEventNofityTask(std::shared_ptr<DCamer
         return ret;
     }
 
-    ret = camDev->ExecuteCameraEventNotify(camEvent);
+    ret = camDev->CameraEventNotify(camEvent);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceConfigStreamState ExecuteCameraEventNotify failed, ret: %d", ret);
+        DHLOGE("DCameraSourceConfigStreamState CameraEventNotify failed, ret: %d", ret);
         return ret;
     }
     return DCAMERA_OK;
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_init_state.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_init_state.cpp
index cd484c2ea04ebd3799a0b03b68bd24c9fc1c3281..fe0d4c5db1dbe443126173af41daf72e53bd96e6 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_init_state.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_init_state.cpp
@@ -58,7 +58,7 @@ int32_t DCameraSourceInitState::DoRegisterTask(std::shared_ptr<DCameraSourceDev>
     if (ret != DCAMERA_OK) {
         return ret;
     }
-    ret = camDev->ExecuteRegister(param);
+    ret = camDev->Register(param);
     if (ret != DCAMERA_OK) {
         return ret;
     }
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_opened_state.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_opened_state.cpp
index 021b5b2514ee666d6b011656f7e36d384b7e37e9..d9ca1fa2296add46556238d109ad04b9693e6188 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_opened_state.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_opened_state.cpp
@@ -68,15 +68,15 @@ int32_t DCameraSourceOpenedState::DoUnregisterTask(std::shared_ptr<DCameraSource
     std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
     camEvent->eventType_ = DCAMERA_MESSAGE;
     camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
-    int32_t ret = camDev->ExecuteCameraEventNotify(camEvent);
+    int32_t ret = camDev->CameraEventNotify(camEvent);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceOpenedState DoUnregisterTask ExecuteCameraEventNotify failed: %d", ret);
+        DHLOGE("DCameraSourceOpenedState DoUnregisterTask CameraEventNotify failed: %d", ret);
         return ret;
     }
 
-    ret = camDev->ExecuteCloseCamera();
+    ret = camDev->CloseCamera();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceOpenedState DoUnregisterTask ExecuteCloseCamera failed: %d", ret);
+        DHLOGE("DCameraSourceOpenedState DoUnregisterTask CloseCamera failed: %d", ret);
         return ret;
     }
 
@@ -85,9 +85,9 @@ int32_t DCameraSourceOpenedState::DoUnregisterTask(std::shared_ptr<DCameraSource
     if (ret != DCAMERA_OK) {
         return ret;
     }
-    ret = camDev->ExecuteUnRegister(param);
+    ret = camDev->UnRegister(param);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceOpenedState DoUnregisterTask ExecuteUnRegister failed: %d", ret);
+        DHLOGE("DCameraSourceOpenedState DoUnregisterTask UnRegister failed: %d", ret);
         return ret;
     }
     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
@@ -108,9 +108,9 @@ int32_t DCameraSourceOpenedState::DoConfigStreamsTask(std::shared_ptr<DCameraSou
         return ret;
     }
 
-    ret = camDev->ExecuteConfigStreams(streamInfos);
+    ret = camDev->ConfigStreams(streamInfos);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceOpenedState ExecuteConfigStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceOpenedState ConfigStreams failed, ret: %d", ret);
         return ret;
     }
     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
@@ -138,9 +138,9 @@ int32_t DCameraSourceOpenedState::DoUpdateSettingsTask(std::shared_ptr<DCameraSo
         return ret;
     }
 
-    ret = camDev->ExecuteUpdateSettings(settings);
+    ret = camDev->UpdateSettings(settings);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceOpenedState ExecuteConfigStreams failed, ret: %d", ret);
+        DHLOGE("DCameraSourceOpenedState UpdateSettings failed, ret: %d", ret);
         return ret;
     }
     return DCAMERA_OK;
@@ -154,9 +154,9 @@ int32_t DCameraSourceOpenedState::DoOpenTask(std::shared_ptr<DCameraSourceDev>&
 
 int32_t DCameraSourceOpenedState::DoCloseTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
-    int32_t ret = camDev->ExecuteCloseCamera();
+    int32_t ret = camDev->CloseCamera();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceOpenedState DoOpenTask ExecuteCloseCamera failed, ret: %d", ret);
+        DHLOGE("DCameraSourceOpenedState DoOpenTask CloseCamera failed, ret: %d", ret);
         return ret;
     }
     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
@@ -177,9 +177,9 @@ int32_t DCameraSourceOpenedState::DoEventNofityTask(std::shared_ptr<DCameraSourc
         return ret;
     }
 
-    ret = camDev->ExecuteCameraEventNotify(camEvent);
+    ret = camDev->CameraEventNotify(camEvent);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceOpenedState DoEventNofityTask ExecuteCameraEventNotify failed, ret: %d", ret);
+        DHLOGE("DCameraSourceOpenedState DoEventNofityTask CameraEventNotify failed, ret: %d", ret);
         return ret;
     }
     return DCAMERA_OK;
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_regist_state.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_regist_state.cpp
index acc17c9ef260abd38dfaeb4b24b13e5351f3e22a..588552cb62a30b817918c8cec994f3e4df31c710 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_regist_state.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_regist_state.cpp
@@ -68,7 +68,7 @@ int32_t DCameraSourceRegistState::DoUnregisterTask(std::shared_ptr<DCameraSource
     if (ret != DCAMERA_OK) {
         return ret;
     }
-    ret = camDev->ExecuteUnRegister(param);
+    ret = camDev->UnRegister(param);
     if (ret != DCAMERA_OK) {
         return ret;
     }
@@ -83,9 +83,9 @@ int32_t DCameraSourceRegistState::DoUnregisterTask(std::shared_ptr<DCameraSource
 
 int32_t DCameraSourceRegistState::DoOpenTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
-    int32_t ret = camDev->ExecuteOpenCamera();
+    int32_t ret = camDev->OpenCamera();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceRegistState ExecuteOpenCamera failed, ret: %d", ret);
+        DHLOGE("DCameraSourceRegistState OpenCamera failed, ret: %d", ret);
         return ret;
     }
     return DCAMERA_OK;
@@ -106,9 +106,9 @@ int32_t DCameraSourceRegistState::DoEventNofityTask(std::shared_ptr<DCameraSourc
         return ret;
     }
 
-    ret = camDev->ExecuteCameraEventNotify(camEvent);
+    ret = camDev->CameraEventNotify(camEvent);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceRegistState DoEventNofityTask ExecuteCameraEventNotify failed, ret: %d", ret);
+        DHLOGE("DCameraSourceRegistState DoEventNofityTask CameraEventNotify failed, ret: %d", ret);
         return ret;
     }
     return DCAMERA_OK;
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_dev.h b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_dev.h
index 29b637b0e697140fdd099a8283d26df974a0275b..faea29652a087438c8ff58e818a029a337f76d50 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_dev.h
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_dev.h
@@ -29,53 +29,53 @@ public:
         : DCameraSourceDev(devId, dhId, stateLisener) {};
     ~MockDCameraSourceDev() = default;
 
-    int32_t ExecuteRegister(std::shared_ptr<DCameraRegistParam>& param)
+    int32_t Register(std::shared_ptr<DCameraRegistParam>& param)
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteUnRegister(std::shared_ptr<DCameraRegistParam>& param)
+    int32_t UnRegister(std::shared_ptr<DCameraRegistParam>& param)
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteOpenCamera()
+    int32_t OpenCamera()
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteCloseCamera()
+    int32_t CloseCamera()
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos)
+    int32_t ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos)
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease)
+    int32_t ReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease)
     {
         isAllRelease = true;
         return DCAMERA_OK;
     }
-    int32_t ExecuteReleaseAllStreams()
+    int32_t ReleaseAllStreams()
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteStartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos)
+    int32_t StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos)
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteStopCapture(std::vector<int>& streamIds, bool& isAllStop)
+    int32_t StopCapture(std::vector<int>& streamIds, bool& isAllStop)
     {
         isAllStop = true;
         return DCAMERA_OK;
     }
-    int32_t ExecuteStopAllCapture()
+    int32_t StopAllCapture()
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteUpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
+    int32_t UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteCameraEventNotify(std::shared_ptr<DCameraEvent>& events)
+    int32_t CameraEventNotify(std::shared_ptr<DCameraEvent>& events)
     {
         return DCAMERA_OK;
     }