diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_service_ipc.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_service_ipc.cpp
index 79de79dc254f299b35a8b15f6ef8f8745bff501d..0b66670e8f88b3578384fb1a2fb81dddfa27ae05 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_service_ipc.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_service_ipc.cpp
@@ -106,7 +106,9 @@ sptr<IDistributedCameraSink> DCameraSourceServiceIpc::GetSinkRemoteCamSrv(const
         std::lock_guard<std::mutex> autoLock(sinkRemoteCamSrvLock_);
         auto iter = remoteSinks_.find(deviceId);
         if (iter != remoteSinks_.end()) {
-            iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
+            if (iter->second != nullptr && iter->second->AsObject() != nullptr) {
+                iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
+            }
         }
         remoteSinks_[deviceId] = remoteCamSrvObj;
     }
@@ -125,7 +127,9 @@ void DCameraSourceServiceIpc::DeleteSinkRemoteCamSrv(const std::string& deviceId
     }
 
     if (item->second != nullptr) {
-        item->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
+        if (iter->second != nullptr && iter->second->AsObject() != nullptr) {
+            item->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
+        }
     }
     remoteSinks_.erase(item);
 }
@@ -136,7 +140,9 @@ void DCameraSourceServiceIpc::ClearSinkRemoteCamSrv()
     std::lock_guard<std::mutex> autoLock(sinkRemoteCamSrvLock_);
     for (auto iter = remoteSinks_.begin(); iter != remoteSinks_.end(); iter++) {
         if (iter->second != nullptr) {
-            iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
+            if (iter->second != nullptr && iter->second->AsObject() != nullptr) {
+                iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
+            }
         }
     }
     remoteSinks_.clear();
@@ -169,7 +175,9 @@ void DCameraSourceServiceIpc::OnSinkRemoteCamSrvDied(const wptr<IRemoteObject>&
 
     DHLOGI("OnSinkRemoteCamSrvDied remote.devId: %{public}s", GetAnonyString(iter->first).c_str());
     if (iter->second != nullptr) {
-        iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
+        if (iter->second != nullptr && iter->second->AsObject() != nullptr) {
+            iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
+        }
     }
     remoteSinks_.erase(iter);
 }
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
index 7f75d017c15f24cd6db06ceb84d019afd0f8c582..a78f0852ed92b9aedb5934d5afbb168a16a9e7bb 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
@@ -63,11 +63,10 @@ DCameraSourceController::~DCameraSourceController()
 
 int32_t DCameraSourceController::StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos)
 {
-    if (indexs_.size() > DCAMERA_MAX_NUM) {
+    if (indexs.size() == 0 || indexs_.size() > DCAMERA_MAX_NUM) {
         DHLOGE("StartCapture not support operate %{public}zu camera", indexs_.size());
         return DCAMERA_BAD_OPERATE;
     }
-
     std::string dhId = indexs_.begin()->dhId_;
     std::string devId = indexs_.begin()->devId_;
     DHLOGI("StartCapture devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
@@ -176,6 +175,7 @@ int32_t DCameraSourceController::ChannelNeg(std::shared_ptr<DCameraChannelInfo>&
 
 int32_t DCameraSourceController::DCameraNotify(std::shared_ptr<DCameraEvent>& events)
 {
+    HECK_AND_RETURN_RET_LOG(events == nullptr, DCAMERA_BAD_VALUE, "Event is null");
     if (events->eventResult_ == DCAMERA_EVENT_CAMERA_ERROR) {
         DcameraFinishAsyncTrace(DCAMERA_CONTINUE_FIRST_FRAME, DCAMERA_CONTINUE_FIRST_FRAME_TASKID);
         DcameraFinishAsyncTrace(DCAMERA_SNAPSHOT_FIRST_FRAME, DCAMERA_SNAPSHOT_FIRST_FRAME_TASKID);
@@ -487,6 +487,9 @@ void DCameraSourceController::HandleMetaDataResult(std::string& jsonStr)
     dhBase.dhId_ = dhId_;
     for (auto iter = cmd.value_.begin(); iter != cmd.value_.end(); iter++) {
         DCameraSettings setting;
+        if ((*iter) == nullptr) {
+            continue;
+        }
         setting.type_ = (*iter)->type_;
         setting.value_ = (*iter)->value_;
         int32_t retHdi = camHdiProvider_->OnSettingsResult(dhBase, setting);
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_data_process.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_data_process.cpp
index f264135d4a3b8f999bb602c9cad65e1df464ed09..408e4177c0b9c59b3d5ac046a0da72608eaec720 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_data_process.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_data_process.cpp
@@ -54,12 +54,15 @@ int32_t DCameraSourceDataProcess::FeedStream(std::vector<std::shared_ptr<DataBuf
     }
 
     auto buffer = *(buffers.begin());
+    CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
     buffersSize = static_cast<uint64_t>(buffer->Size());
     DHLOGD("DCameraSourceDataProcess FeedStream devId %{public}s dhId %{public}s streamType %{public}d streamSize: "
         "%{public}" PRIu64, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, buffersSize);
     std::lock_guard<std::mutex> autoLock(streamMutex_);
     for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
-        (*iter)->FeedStream(buffer);
+        if ((*iter) != nullptr) {
+            (*iter)->FeedStream(buffer);
+        }
     }
     return DCAMERA_OK;
 }
@@ -76,6 +79,9 @@ int32_t DCameraSourceDataProcess::ConfigStreams(std::vector<std::shared_ptr<DCSt
     std::map<DCameraStreamConfig, std::set<int>> streamConfigs;
     for (auto iter = streamInfos.begin(); iter != streamInfos.end(); iter++) {
         std::shared_ptr<DCStreamInfo> streamInfo = *iter;
+        if (streamInfo == nullptr)
+            continue;
+        }
         DCameraStreamConfig streamConfig(streamInfo->width_, streamInfo->height_, streamInfo->format_,
             streamInfo->dataspace_, streamInfo->encodeType_, streamInfo->type_);
         DHLOGI("DCameraSourceDataProcess ConfigStreams devId %{public}s dhId %{public}s, streamId: %{public}d info: "
@@ -119,9 +125,11 @@ int32_t DCameraSourceDataProcess::ReleaseStreams(std::vector<int32_t>& streamIds
     std::set<int32_t> streamIdSet(streamIds.begin(), streamIds.end());
     auto iter = streamProcess_.begin();
     while (iter != streamProcess_.end()) {
-        (*iter)->ReleaseStreams(streamIdSet);
-        std::set<int32_t> processStreamIds;
-        (*iter)->GetAllStreamIds(processStreamIds);
+        if ((*iter) != nullptr) {
+            (*iter)->ReleaseStreams(streamIdSet);
+            std::set<int32_t> processStreamIds;
+            (*iter)->GetAllStreamIds(processStreamIds);
+        }
         if (processStreamIds.empty()) {
             iter = streamProcess_.erase(iter);
         } else {
@@ -143,6 +151,7 @@ int32_t DCameraSourceDataProcess::ReleaseStreams(std::vector<int32_t>& streamIds
 
 int32_t DCameraSourceDataProcess::StartCapture(std::shared_ptr<DCCaptureInfo>& captureInfo)
 {
+    CHECK_AND_RETURN_RET_LOG((captureInfo == nullptr), DCAMERA_BAD_VALUE, "CaptureInfo is null.");
     DHLOGI("DCameraSourceDataProcess StartCapture devId %{public}s dhId %{public}s width: %{public}d, height: "
         "%{public}d, format: %{public}d, isCapture: %{public}d, dataspace: %{public}d, encodeType: %{public}d, "
         "streamType: %{public}d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
@@ -161,6 +170,9 @@ int32_t DCameraSourceDataProcess::StartCapture(std::shared_ptr<DCCaptureInfo>& c
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), *iterSet);
     }
     for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
+        if ((*iter) == nullptr)
+            continue;
+        }
         (*iter)->StartCapture(streamConfig, streamIds);
     }
     return DCAMERA_OK;
@@ -176,6 +188,9 @@ int32_t DCameraSourceDataProcess::StopCapture(std::vector<int32_t>& streamIds)
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), *iterSet);
     }
     for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
+        if ((*iter) == nullptr)
+            continue;
+        }
         (*iter)->StopCapture(streamIdSet);
     }
     if ((streamType_ == CONTINUOUS_FRAME) && (GetProducerSize() == 0)) {
@@ -189,6 +204,9 @@ void DCameraSourceDataProcess::DestroyPipeline()
     DHLOGI("DCameraSourceDataProcess DestroyPipeline devId %{public}s dhId %{public}s streamType: %{public}d",
         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_);
     for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
+        if ((*iter) == nullptr)
+            continue;
+        }
         (*iter)->DestroyPipeline();
     }
 }
@@ -198,6 +216,9 @@ int32_t DCameraSourceDataProcess::GetProducerSize()
     int32_t ret = 0;
     for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
         std::shared_ptr<DCameraStreamDataProcess> streamDataProcess = *iter;
+        if (streamDataProcess == nullptr)
+            continue;
+        }
         int32_t size = streamDataProcess->GetProducerSize();
         ret += size;
     }
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
index 857415d7474c0f47a4297acdce22a86a70d02840..8af55d8388ac4de30caf02c28bb86f2f14744163 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
@@ -64,6 +64,9 @@ int32_t DCameraSourceInput::ConfigStreams(std::vector<std::shared_ptr<DCStreamIn
     std::vector<std::shared_ptr<DCStreamInfo>> continueStreams;
     for (auto iter = streamInfos.begin(); iter != streamInfos.end(); iter++) {
         std::shared_ptr<DCStreamInfo> streamInfo = *iter;
+        if (streamInfo == nullptr)
+            continue;
+        }
         DHLOGI("DCameraSourceInput ConfigStreams devId: %{public}s, dhId: %{public}s, streamId: %{public}d, width: "
             "%{public}d, height: %{public}d, format: %{public}d, dataspace: %{public}d, encodeType:%{public}d "
             "streamType: %{public}d", GetAnonyString(devId_).c_str(),
@@ -102,12 +105,14 @@ int32_t DCameraSourceInput::ReleaseStreams(std::vector<int>& streamIds, bool& is
 {
     DHLOGI("DCameraSourceInput ReleaseStreams devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
+    CHECK_AND_RETURN_RET_LOG((dataProcess_[CONTINUOUS_FRAME] == nullptr), DCAMERA_BAD_VALUE, "dataProcess is null.");
     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->ReleaseStreams(streamIds);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceInput ReleaseStreams continue stream ReleaseStreams ret: %{public}d, devId: %{public}s,"
             " dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
         return ret;
     }
+    CHECK_AND_RETURN_RET_LOG((dataProcess_[SNAPSHOT_FRAME] == nullptr), DCAMERA_BAD_VALUE, "dataProcess is null.");
     ret = dataProcess_[SNAPSHOT_FRAME]->ReleaseStreams(streamIds);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceInput ReleaseStreams snapshot stream ReleaseStreams ret: %{public}d, devId: %{public}s, "
@@ -131,6 +136,9 @@ int32_t DCameraSourceInput::StartCapture(std::vector<std::shared_ptr<DCCaptureIn
         GetAnonyString(dhId_).c_str());
     for (auto iter = captureInfos.begin(); iter != captureInfos.end(); iter++) {
         int32_t ret = DCAMERA_OK;
+        if ((*iter) == nullptr)
+            continue;
+        }
         for (auto iterSet = (*iter)->streamIds_.begin(); iterSet != (*iter)->streamIds_.end(); iterSet++) {
             DHLOGI("DCameraSourceInput StartCapture devId %{public}s dhId %{public}s StartCapture id: %{public}d",
                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), *iterSet);
@@ -153,6 +161,8 @@ int32_t DCameraSourceInput::StopCapture(std::vector<int>& streamIds, bool& isAll
 {
     DHLOGI("DCameraSourceInput StopCapture devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
+    CHECK_AND_RETURN_RET_LOG((dataProcess_[CONTINUOUS_FRAME] == nullptr), DCAMERA_BAD_VALUE, "dataProcess of continuous is null.");
+    CHECK_AND_RETURN_RET_LOG((dataProcess_[SNAPSHOT_FRAME] == nullptr), DCAMERA_BAD_VALUE, "dataProcess of snapshot is null.");
     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture(streamIds);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceInput StopCapture continue ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
@@ -202,6 +212,8 @@ int32_t DCameraSourceInput::OpenChannel(std::vector<DCameraIndex>& indexs)
 
 int32_t DCameraSourceInput::CloseChannel()
 {
+    CHECK_AND_RETURN_RET_LOG((channels_[CONTINUOUS_FRAME] == nullptr), DCAMERA_BAD_VALUE, "Channel is null.");
+    CHECK_AND_RETURN_RET_LOG((channels_[SNAPSHOT_FRAME] == nullptr), DCAMERA_BAD_VALUE, "Channel of snapshot is null.");
     DHLOGI("DCameraSourceInput CloseChannel devId %{public}s dhId %{public}s continue state: %{public}d, "
         "snapshot state: %{public}d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
         channelState_[CONTINUOUS_FRAME], channelState_[SNAPSHOT_FRAME]);
@@ -335,6 +347,10 @@ void DCameraSourceInput::OnSessionError(DCStreamType streamType, int32_t eventTy
 
 void DCameraSourceInput::OnDataReceived(DCStreamType streamType, std::vector<std::shared_ptr<DataBuffer>>& buffers)
 {
+    if (buffers.empty() || buffers[0] == nullptr) {
+        DHLOGE("buffer is null.");
+        return;
+    }
     buffers[0]->frameInfo_.offset = DCameraSoftbusLatency::GetInstance().GetTimeSyncInfo(devId_);
     int32_t ret = dataProcess_[streamType]->FeedStream(buffers);
     if (ret != DCAMERA_OK) {
@@ -348,6 +364,7 @@ int32_t DCameraSourceInput::ReleaseAllStreams()
     DHLOGI("ReleaseAllStreams devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
     std::vector<int> continueStreamIds;
+    CHECK_AND_RETURN_RET_LOG((dataProcess_[CONTINUOUS_FRAME] == nullptr), DCAMERA_BAD_VALUE, "dataProcess is null.");
     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->ReleaseStreams(continueStreamIds);
     if (ret != DCAMERA_OK) {
@@ -372,6 +389,10 @@ int32_t DCameraSourceInput::StopAllCapture()
     DHLOGI("StopAllCapture devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
     std::vector<int> continueStreamIds;
+    CHECK_AND_RETURN_RET_LOG((dataProcess_[CONTINUOUS_FRAME] == nullptr), DCAMERA_BAD_VALUE,
+        "dataProcess of continous frame is null.");
+    CHECK_AND_RETURN_RET_LOG((dataProcess_[SNAPSHOT_FRAME] == nullptr), DCAMERA_BAD_VALUE,
+        "dataProcess of snapshot frame is null.");
     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture(continueStreamIds);
     if (ret != DCAMERA_OK) {
@@ -404,6 +425,7 @@ void DCameraSourceInput::PostChannelDisconnectedEvent()
 int32_t DCameraSourceInput::EstablishContinuousFrameSession(std::vector<DCameraIndex>& indexs)
 {
     DcameraStartAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
+    CHECK_AND_RETURN_RET_LOG((channels_[CONTINUOUS_FRAME] == nullptr), DCAMERA_BAD_VALUE, "Channel is null.");
     int32_t ret = channels_[CONTINUOUS_FRAME]->CreateSession(indexs, CONTINUE_SESSION_FLAG, DCAMERA_SESSION_MODE_VIDEO,
         listeners_[CONTINUOUS_FRAME]);
     if (ret != DCAMERA_OK) {
@@ -421,6 +443,7 @@ int32_t DCameraSourceInput::EstablishContinuousFrameSession(std::vector<DCameraI
 int32_t DCameraSourceInput::EstablishSnapshotFrameSession(std::vector<DCameraIndex>& indexs)
 {
     DcameraStartAsyncTrace(DCAMERA_OPEN_DATA_SNAPSHOT, DCAMERA_OPEN_DATA_SNAPSHOT_TASKID);
+    CHECK_AND_RETURN_RET_LOG((channels_[CONTINUOUS_FRAME] == nullptr), DCAMERA_BAD_VALUE, "Channel is null.");
     int32_t ret = channels_[SNAPSHOT_FRAME]->CreateSession(indexs, SNAP_SHOT_SESSION_FLAG, DCAMERA_SESSION_MODE_JPEG,
         listeners_[SNAPSHOT_FRAME]);
     if (ret != DCAMERA_OK) {
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp
index 93daa0f1c578a2a51f38aa00f8400add87c110ad..fe7a4486e7852d228b157b13590732e79f4a99c6 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp
@@ -47,6 +47,7 @@ DCameraStreamDataProcess::~DCameraStreamDataProcess()
 
 void DCameraStreamDataProcess::FeedStream(std::shared_ptr<DataBuffer>& buffer)
 {
+    CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
     for (auto streamId : streamIds_) {
         uint64_t buffersSize = static_cast<uint64_t>(buffer->Size());
         DHLOGD("FeedStream devId %{public}s dhId %{public}s streamId %{public}d streamType %{public}d streamSize: "
@@ -70,6 +71,10 @@ void DCameraStreamDataProcess::FeedStream(std::shared_ptr<DataBuffer>& buffer)
 void DCameraStreamDataProcess::ConfigStreams(std::shared_ptr<DCameraStreamConfig>& dstConfig,
     std::set<int32_t>& streamIds)
 {
+    if (dstConfig == nullptr) {
+        DHLOGE("Stream Config is null.");
+        return;
+    }
     for (auto streamId : streamIds) {
         DHLOGI("ConfigStreams devId %{public}s dhId %{public}s streamId %{public}d, width: %{public}d, height: "
             "%{public}d, format: %{public}d, dataspace: %{public}d, encodeType: %{public}d, streamType: %{public}d",
@@ -96,6 +101,10 @@ void DCameraStreamDataProcess::ReleaseStreams(std::set<int32_t>& streamIds)
         if (producerIter == producers_.end()) {
             continue;
         }
+        if (producerIter->second == nullptr) {
+            DHLOGE("Preducer is null.");
+            continue;
+        }
         producerIter->second->Stop();
         producers_.erase(streamId);
     }
@@ -104,6 +113,10 @@ void DCameraStreamDataProcess::ReleaseStreams(std::set<int32_t>& streamIds)
 void DCameraStreamDataProcess::StartCapture(std::shared_ptr<DCameraStreamConfig>& srcConfig,
     std::set<int32_t>& streamIds)
 {
+    if (srcConfig == nullptr) {
+        DHLOGE("Stream Config of source is null.");
+        return;
+    }
     for (auto iter = streamIds.begin(); iter != streamIds.end(); iter++) {
         DHLOGI("StartCapture devId %{public}s dhId %{public}s streamType: %{public}d streamId: %{public}d, "
             "srcConfig: width: %{public}d, height: %{public}d, format: %{public}d, dataspace: %{public}d, "
@@ -165,6 +178,10 @@ void DCameraStreamDataProcess::StopCapture(std::set<int32_t>& streamIds)
             }
             DHLOGI("StopCapture stop producer, devId %{public}s dhId %{public}s streamType: %{public}d streamId: "
                 "%{public}d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId);
+            if (producerIter->second == nullptr) {
+                DHLOGE("Preducer is null.");
+                continue;
+            }
             producerIter->second->Stop();
             producerIter = producers_.erase(producerIter);
         }
@@ -192,6 +209,10 @@ void DCameraStreamDataProcess::FeedStreamToSnapShot(const std::shared_ptr<DataBu
         streamType_, buffersSize);
     std::lock_guard<std::mutex> autoLock(producerMutex_);
     for (auto iter = producers_.begin(); iter != producers_.end(); iter++) {
+        if (iter->second == nullptr) {
+            DHLOGE("Preducer is null.");
+            continue;
+        }
         iter->second->FeedStream(buffer);
     }
 }
@@ -225,6 +246,10 @@ void DCameraStreamDataProcess::OnProcessedVideoBuffer(const std::shared_ptr<Data
         streamType_, resultSize);
     std::lock_guard<std::mutex> autoLock(producerMutex_);
     for (auto iter = producers_.begin(); iter != producers_.end(); iter++) {
+        if (iter->second == nullptr) {
+            DHLOGE("Preducer is null.");
+            continue;
+        }
         iter->second->FeedStream(videoResult);
     }
 }
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process_producer.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process_producer.cpp
index d220992d3652284e2007a6a00273d9680fb248fa..5e6866b0198f0dd03669b74440867539c4e0d9e3 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process_producer.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process_producer.cpp
@@ -108,6 +108,7 @@ void DCameraStreamDataProcessProducer::Stop()
 
 void DCameraStreamDataProcessProducer::FeedStream(const std::shared_ptr<DataBuffer>& buffer)
 {
+    CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
     buffer->frameInfo_.timePonit.startSmooth = GetNowTimeStampUs();
     {
         std::lock_guard<std::mutex> lock(bufferMutex_);
@@ -211,6 +212,7 @@ int32_t DCameraStreamDataProcessProducer::FeedStreamToDriver(const DHBase& dhBas
         return DCAMERA_BAD_OPERATE;
     }
     do {
+        CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
         ret = CheckSharedMemory(sharedMemory, buffer);
         if (ret != DCAMERA_OK) {
             DHLOGE("CheckSharedMemory failed devId: %{public}s dhId: %{public}s", GetAnonyString(devId_).c_str(),
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/base/ifeeding_smoother.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/base/ifeeding_smoother.cpp
index 1aeff239f37380357fb5e8aa2882c97e12bc320e..57a1476b2ee5b8035120510fd35646490c93a10f 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/base/ifeeding_smoother.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/base/ifeeding_smoother.cpp
@@ -95,6 +95,10 @@ void IFeedingSmoother::LooperSmooth()
 
 void IFeedingSmoother::SmoothFeeding(const std::shared_ptr<IFeedableData>& data)
 {
+    if (data == nullptr) {
+        DHLOGE("Feed data is null.");
+        return;
+    }
     int64_t enterTime = GetNowTimeStampUs();
     SetClockTime(enterTime);
     int64_t timeStamp = data->GetTimeStamp();
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/base/time_statistician.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/base/time_statistician.cpp
index 31c8c4402ac149602df488e52a07c38f8876fa2a..f361db6c35073ea0cc2119ffb9232b642a5edccf 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/base/time_statistician.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/base/time_statistician.cpp
@@ -20,6 +20,10 @@ namespace OHOS {
 namespace DistributedHardware {
 void TimeStatistician::CalProcessTime(const std::shared_ptr<IFeedableData>& data)
 {
+    if (data == nullptr) {
+        DHLOGE("Feed data is null.");
+        return;
+    }
     int64_t feedTime  = GetNowTimeStampUs();
     int64_t timeStamp = data->GetTimeStamp();
     CalAverFeedInterval(feedTime);
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/derived/dcamera_feeding_smoother.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/derived/dcamera_feeding_smoother.cpp
index 635ccfd83b9f8d02e8c7c67f1a0cc26f7be4841b..b1a695cec10d5d9cd751358282b2a74c27213d21 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/derived/dcamera_feeding_smoother.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/derived/dcamera_feeding_smoother.cpp
@@ -51,6 +51,7 @@ void DCameraFeedingSmoother::InitTimeStatistician()
 int32_t DCameraFeedingSmoother::NotifySmoothFinished(const std::shared_ptr<IFeedableData>& data)
 {
     int64_t finishSmoothT = GetNowTimeStampUs();
+    CHECK_AND_RETURN_RET_LOG((data == nullptr), NOTIFY_FAILED, "Feed data is null.");
     std::shared_ptr<DataBuffer> buffer = std::reinterpret_pointer_cast<DataBuffer>(data);
     buffer->frameInfo_.timePonit.finishSmooth = finishSmoothT;
     CHECK_AND_RETURN_RET_LOG(dCameraStatistician_ == nullptr, NOTIFY_FAILED, "dCameraStatistician_ is null.");
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/derived/dcamera_time_statistician.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/derived/dcamera_time_statistician.cpp
index 389bffd1443d93cbb65ea6dec183b397f38b209e..f3635597ecb191a45cd5d1b6aa8aa223c73690af 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/derived/dcamera_time_statistician.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/feedingsmoother/derived/dcamera_time_statistician.cpp
@@ -21,6 +21,10 @@ namespace OHOS {
 namespace DistributedHardware {
 void DCameraTimeStatistician::CalProcessTime(const std::shared_ptr<IFeedableData>& data)
 {
+    if (data == nullptr) {
+        DHLOGE("Feed data is null.");
+        return;
+    }
     TimeStatistician::CalProcessTime(data);
     std::shared_ptr<DataBuffer> dataBuffer = std::reinterpret_pointer_cast<DataBuffer>(data);
     DCameraFrameInfo frameInfo = dataBuffer->frameInfo_;
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 cb79c5565038e7231ae3889ebde0c6d55105a788..975e222d1d912aa51b7956bd270aef6a23071b20 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
@@ -89,6 +89,7 @@ int32_t DCameraSourceCaptureState::DoRegisterTask(std::shared_ptr<DCameraSourceD
 int32_t DCameraSourceCaptureState::DoUnregisterTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
     camEvent->eventType_ = DCAMERA_MESSAGE;
     camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
@@ -143,6 +144,7 @@ int32_t DCameraSourceCaptureState::DoOpenTask(std::shared_ptr<DCameraSourceDev>&
 
 int32_t DCameraSourceCaptureState::DoCloseTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     int32_t ret = camDev->StopAllCapture();
     if (ret != DCAMERA_OK) {
         DHLOGE("StopAllCapture failed, ret: %{public}d", ret);
@@ -172,6 +174,7 @@ int32_t DCameraSourceCaptureState::DoCloseTask(std::shared_ptr<DCameraSourceDev>
 int32_t DCameraSourceCaptureState::DoStartCaptureTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
     int32_t ret = event.GetCaptureInfos(captureInfos);
     if (ret != DCAMERA_OK) {
@@ -196,6 +199,7 @@ int32_t DCameraSourceCaptureState::DoStopCaptureTask(std::shared_ptr<DCameraSour
     }
 
     bool isAllStop = false;
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     ret = camDev->StopCapture(streamIds, isAllStop);
     if (ret != DCAMERA_OK) {
         DHLOGE("StopCapture failed, ret: %{public}d", ret);
@@ -221,7 +225,7 @@ int32_t DCameraSourceCaptureState::DoUpdateSettingsTask(std::shared_ptr<DCameraS
     if (ret != DCAMERA_OK) {
         return ret;
     }
-
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     ret = camDev->UpdateSettings(settings);
     if (ret != DCAMERA_OK) {
         DHLOGE("UpdateSettings failed, ret: %{public}d", ret);
@@ -238,7 +242,7 @@ int32_t DCameraSourceCaptureState::DoEventNofityTask(std::shared_ptr<DCameraSour
     if (ret != DCAMERA_OK) {
         return ret;
     }
-
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     ret = camDev->CameraEventNotify(camEvent);
     if (ret != DCAMERA_OK) {
         DHLOGE("CameraEventNotify failed, ret: %{public}d", ret);
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 c76804efacc325302fabb46cfa8d417cfa014c16..9e1825e57a4c06b8d630bccf1f8acfe877fa7d38 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
@@ -98,6 +98,7 @@ int32_t DCameraSourceConfigStreamState::DoRegisterTask(std::shared_ptr<DCameraSo
 int32_t DCameraSourceConfigStreamState::DoUnregisterTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
     camEvent->eventType_ = DCAMERA_MESSAGE;
     camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
@@ -147,6 +148,7 @@ int32_t DCameraSourceConfigStreamState::DoOpenTask(std::shared_ptr<DCameraSource
 int32_t DCameraSourceConfigStreamState::DoCloseTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     int32_t ret = camDev->CloseCamera();
     if (ret != DCAMERA_OK) {
         DHLOGE("CloseCamera failed, ret: %{public}d", ret);
@@ -170,6 +172,7 @@ int32_t DCameraSourceConfigStreamState::DoCloseTask(std::shared_ptr<DCameraSourc
 int32_t DCameraSourceConfigStreamState::DoConfigStreamsTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
     int32_t ret = event.GetStreamInfos(streamInfos);
     if (ret != DCAMERA_OK) {
@@ -196,6 +199,7 @@ int32_t DCameraSourceConfigStreamState::DoConfigStreamsTask(std::shared_ptr<DCam
 int32_t DCameraSourceConfigStreamState::DoReleaseStreamsTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::vector<int> streamIds;
     int32_t ret = event.GetStreamIds(streamIds);
     if (ret != DCAMERA_OK) {
@@ -223,6 +227,7 @@ int32_t DCameraSourceConfigStreamState::DoReleaseStreamsTask(std::shared_ptr<DCa
 int32_t DCameraSourceConfigStreamState::DoStartCaptureTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
     int32_t ret = event.GetCaptureInfos(captureInfos);
     if (ret != DCAMERA_OK) {
@@ -253,6 +258,7 @@ int32_t DCameraSourceConfigStreamState::DoStopCaptureTask(std::shared_ptr<DCamer
 int32_t DCameraSourceConfigStreamState::DoUpdateSettingsTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::vector<std::shared_ptr<DCameraSettings>> settings;
     int32_t ret = event.GetCameraSettings(settings);
     if (ret != DCAMERA_OK) {
@@ -270,6 +276,7 @@ int32_t DCameraSourceConfigStreamState::DoUpdateSettingsTask(std::shared_ptr<DCa
 int32_t DCameraSourceConfigStreamState::DoEventNofityTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::shared_ptr<DCameraEvent> camEvent;
     int32_t ret = event.GetCameraEvent(camEvent);
     if (ret != 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 ca54607449de081ebed1c9bbb25b4ba81a7bd1db..56dd822f46935cb8199c2f70f27dbb46f615d9de 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,6 +58,7 @@ DCameraStateType DCameraSourceInitState::GetStateType()
 
 int32_t DCameraSourceInitState::DoRegisterTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::shared_ptr<DCameraRegistParam> param;
     int32_t ret = event.GetDCameraRegistParam(param);
     if (ret != DCAMERA_OK) {
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 1703c3ed871c43a6fb15540776056364ba60cb8a..67bb83911c7a34c3048b2004c650dcb265a3f067 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
@@ -90,6 +90,7 @@ int32_t DCameraSourceOpenedState::DoRegisterTask(std::shared_ptr<DCameraSourceDe
 
 int32_t DCameraSourceOpenedState::DoUnregisterTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
     camEvent->eventType_ = DCAMERA_MESSAGE;
     camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
@@ -127,6 +128,7 @@ int32_t DCameraSourceOpenedState::DoUnregisterTask(std::shared_ptr<DCameraSource
 int32_t DCameraSourceOpenedState::DoConfigStreamsTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
     int32_t ret = event.GetStreamInfos(streamInfos);
     if (ret != DCAMERA_OK) {
@@ -159,6 +161,7 @@ int32_t DCameraSourceOpenedState::DoReleaseStreamsTask(std::shared_ptr<DCameraSo
 int32_t DCameraSourceOpenedState::DoUpdateSettingsTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::vector<std::shared_ptr<DCameraSettings>> settings;
     int32_t ret = event.GetCameraSettings(settings);
     if (ret != DCAMERA_OK) {
@@ -183,6 +186,7 @@ int32_t DCameraSourceOpenedState::DoOpenTask(std::shared_ptr<DCameraSourceDev>&
 
 int32_t DCameraSourceOpenedState::DoCloseTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     int32_t ret = camDev->CloseCamera();
     if (ret != DCAMERA_OK) {
         DHLOGE("CloseCamera failed, ret: %{public}d", ret);
@@ -200,6 +204,7 @@ int32_t DCameraSourceOpenedState::DoCloseTask(std::shared_ptr<DCameraSourceDev>&
 int32_t DCameraSourceOpenedState::DoEventNofityTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::shared_ptr<DCameraEvent> camEvent;
     int32_t ret = event.GetCameraEvent(camEvent);
     if (ret != 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 79d3d7ab61edaf8c70d8d1c418255747caf1bc8b..867e61ef5b7c2327d8cf8c9c19fd608df020a05c 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
@@ -74,6 +74,7 @@ DCameraStateType DCameraSourceRegistState::GetStateType()
 
 int32_t DCameraSourceRegistState::DoRegisterTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     DHLOGI("DCameraSourceRegistState DoRegisterTask");
     std::shared_ptr<DCameraRegistParam> param;
     int32_t ret = event.GetDCameraRegistParam(param);
@@ -92,6 +93,7 @@ int32_t DCameraSourceRegistState::DoRegisterTask(std::shared_ptr<DCameraSourceDe
 
 int32_t DCameraSourceRegistState::DoUnregisterTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::shared_ptr<DCameraRegistParam> param;
     int32_t ret = event.GetDCameraRegistParam(param);
     if (ret != DCAMERA_OK) {
@@ -112,6 +114,7 @@ int32_t DCameraSourceRegistState::DoUnregisterTask(std::shared_ptr<DCameraSource
 
 int32_t DCameraSourceRegistState::DoOpenTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     int32_t ret = camDev->OpenCamera();
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceRegistState OpenCamera failed, ret: %{public}d", ret);
@@ -129,6 +132,7 @@ int32_t DCameraSourceRegistState::DoCloseTask(std::shared_ptr<DCameraSourceDev>&
 int32_t DCameraSourceRegistState::DoEventNofityTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG(camDev == nullptr, DCAMERA_BAD_VALUE, "Camera device is null");
     std::shared_ptr<DCameraEvent> camEvent;
     int32_t ret = event.GetCameraEvent(camEvent);
     if (ret != DCAMERA_OK) {
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_state_machine.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_state_machine.cpp
index 00e6bfc3c465cfbc9fc58d245e8df09912e02bbc..818ba0cc24cf7f2d52745202937ef9cc1b13b9f9 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_state_machine.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_state_machine.cpp
@@ -35,6 +35,7 @@ DCameraSourceStateMachine::~DCameraSourceStateMachine()
 
 int32_t DCameraSourceStateMachine::Execute(DCAMERA_EVENT eventType, DCameraSourceEvent& event)
 {
+    CHECK_AND_RETURN_RET_LOG((currentState_ == nullptr), DCAMERA_BAD_VALUE, "State is null.");
     DHLOGI("In state %{public}d execute event %{public}d", currentState_->GetStateType(), eventType);
     std::shared_ptr<DCameraSourceDev> camDev = camDev_.lock();
     if (camDev == nullptr) {
@@ -51,6 +52,7 @@ int32_t DCameraSourceStateMachine::Execute(DCAMERA_EVENT eventType, DCameraSourc
 
 void DCameraSourceStateMachine::UpdateState(DCameraStateType stateType)
 {
+    CHECK_AND_RETURN_RET_LOG((currentState_ == nullptr), DCAMERA_BAD_VALUE, "State is null.");
     if (stateType != DCAMERA_STATE_INIT) {
         DHLOGI("DCameraSourceStateMachine update state from %{public}d to %{public}d",
             currentState_->GetStateType(), stateType);
@@ -63,6 +65,7 @@ void DCameraSourceStateMachine::UpdateState(DCameraStateType stateType)
 
 int32_t DCameraSourceStateMachine::GetCameraState()
 {
+    CHECK_AND_RETURN_RET_LOG((currentState_ == nullptr), DCAMERA_BAD_VALUE, "State is null.");
     DHLOGI("GetCameraState In state %{public}d", currentState_->GetStateType());
     return currentState_->GetStateType();
 }
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_callback_proxy_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_callback_proxy_test.cpp
index 49425de7871f15e623cfe4416cbd893fe673deb2..1caf763aba367b27ab24969c3a9e7e59522e9466 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_callback_proxy_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_callback_proxy_test.cpp
@@ -73,6 +73,7 @@ HWTEST_F(DcameraSourceCallbackProxyTest, dcamera_source_callback_proxy_test_001,
     DHLOGI("DcameraSourceCallbackProxyTest::dcamera_source_callback_proxy_test_001");
     sptr<ISystemAbilityManager> samgr =
         SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    EXPECT_NE(nullptr, samgr);
     sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID);
     sptr<DCameraSourceCallbackProxy> callbackProxy(new DCameraSourceCallbackProxy(remoteObject));
     EXPECT_EQ(false, callbackProxy == nullptr);
@@ -190,6 +191,7 @@ HWTEST_F(DcameraSourceCallbackProxyTest, OnHardwareStateChanged_001, TestSize.Le
     DHLOGI("DcameraSourceCallbackProxyTest::OnHardwareStateChanged_001");
     sptr<ISystemAbilityManager> samgr =
         SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    EXPECT_NE(nullptr, samgr);
     sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID);
     sptr<DCameraSourceCallbackProxy> callbackProxy(new DCameraSourceCallbackProxy(remoteObject));
 
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_service_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_service_test.cpp
index 9d55180a8a8a5cc4a59444942e7743d6050503c1..8ec0954845a34744503b1478214ed5202c8b8f51 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_service_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_service_test.cpp
@@ -173,6 +173,7 @@ HWTEST_F(DistributedCameraSourceServiceTest, dcamera_source_service_test_006, Te
     std::string params = "test006";
     sptr<ISystemAbilityManager> samgr =
         SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    EXPECT_NE(nullptr, samgr);
     sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID);
     sptr<DCameraSourceCallbackProxy> callbackProxy(new DCameraSourceCallbackProxy(remoteObject));
     testSrcService_->listener_ = std::make_shared<DCameraServiceStateListener>();
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
index 7698aa7d07c715c3b3698ce491bdd029e49f40f1..f16e01024d53088d63550e7e8ba9d141af728a81 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
@@ -97,6 +97,7 @@ void DCameraSourceControllerTest::TearDown(void)
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_001, TestSize.Level1)
 {
+    
     int32_t ret = controller_->Init(indexs_);
     EXPECT_EQ(ret, DCAMERA_INIT_ERR);
 }
@@ -108,6 +109,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_001, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_002, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     int32_t ret = controller_->Init(indexs_);
     EXPECT_EQ(ret, DCAMERA_INIT_ERR);
     ret = controller_->UnInit();
@@ -121,6 +123,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_002, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_003, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
     std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
     capture->width_ = TEST_WIDTH;
@@ -150,6 +153,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_003, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_004, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
     std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
     capture->width_ = TEST_WIDTH;
@@ -181,6 +185,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_004, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_005, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     DHLOGI("start execute dcamera_source_controller_test_005");
     std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
     int32_t ret = GetLocalDeviceNetworkId(chanInfo->sourceDevId_);
@@ -207,6 +212,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_005, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_006, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     DHLOGI("start execute dcamera_source_controller_test_006");
     std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
     std::vector<std::shared_ptr<DCameraSettings>> settings;
@@ -234,6 +240,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_006, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_007, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     DHLOGI("start execute dcamera_source_controller_test_006");
     int32_t ret = controller_->Init(indexs_);
     EXPECT_EQ(ret, DCAMERA_INIT_ERR);
@@ -256,6 +263,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_007, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_008, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     int32_t ret = controller_->Init(indexs_);
     EXPECT_EQ(ret, DCAMERA_INIT_ERR);
     DCameraIndex index1;
@@ -277,6 +285,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_008, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_009, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     int32_t ret = controller_->Init(indexs_);
     EXPECT_EQ(ret, DCAMERA_INIT_ERR);
     DCameraIndex index1;
@@ -299,6 +308,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_009, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_010, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     int32_t ret = controller_->Init(indexs_);
     ret = camDev_->InitDCameraSourceDev();
     std::shared_ptr<ICameraChannelListener> listener =
@@ -323,6 +333,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_010, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_011, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
     int32_t ret = GetLocalDeviceNetworkId(chanInfo->sourceDevId_);
     DCameraChannelDetail continueChInfo(CONTINUE_SESSION_FLAG, CONTINUOUS_FRAME);
@@ -352,6 +363,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_011, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_012, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     std::shared_ptr<DCameraEvent> events = std::make_shared<DCameraEvent>();
     events->eventType_ = 1;
     events->eventResult_ = DCAMERA_EVENT_CAMERA_ERROR;
@@ -369,6 +381,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_012, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_013, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
     std::vector<std::shared_ptr<DCameraSettings>> settings;
     std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
@@ -396,6 +409,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_013, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_014, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     DCameraIndex index1;
     index1.devId_ = TEST_DEVICE_ID;
     index1.dhId_ = TEST_CAMERA_DH_ID_0;
@@ -421,6 +435,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_014, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_015, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     DCameraIndex index1;
     index1.devId_ = TEST_DEVICE_ID;
     index1.dhId_ = TEST_CAMERA_DH_ID_0;
@@ -446,6 +461,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_015, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_016, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     DCameraIndex index1;
     index1.devId_ = TEST_DEVICE_ID;
     index1.dhId_ = TEST_CAMERA_DH_ID_0;
@@ -467,6 +483,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_016, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_017, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     int32_t ret = controller_->Init(indexs_);
     std::string jsonStr = "controllerTest17";
     controller_->HandleMetaDataResult(jsonStr);
@@ -482,6 +499,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_017, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_018, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     int32_t ret = camDev_->InitDCameraSourceDev();
     controller_->PublishEnableLatencyMsg(TEST_DEVICE_ID);
     ret = controller_->UnInit();
@@ -496,6 +514,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_018, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_019, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     int32_t ret = controller_->Init(indexs_);
     std::shared_ptr<DCameraSourceController> controller = nullptr;
     std::shared_ptr<ICameraChannelListener> listener_ =
@@ -520,6 +539,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_019, TestSi
  */
 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_020, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, controller_);
     std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
     std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
     capture->width_ = TEST_WIDTH;
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp
index c5483978b4e8a5d163612d361e78f1fc511ccbfe..792b8b900b9d743371d282aafe00a34cad0a92eb 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp
@@ -116,6 +116,7 @@ void DCameraSourceDevTest::TearDown(void)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_001, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     int32_t ret = camDev_->InitDCameraSourceDev();
     EXPECT_EQ(DCAMERA_OK, ret);
 }
@@ -128,6 +129,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_001, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_002, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     camDev_->InitDCameraSourceDev();
     EnableParam param;
     param.sinkVersion = TEST_VER;
@@ -146,6 +148,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_002, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_003, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     camDev_->InitDCameraSourceDev();
     int32_t ret = camDev_->UnRegisterDistributedHardware(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID);
     EXPECT_EQ(DCAMERA_OK, ret);
@@ -159,6 +162,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_003, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_004, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     camDev_->InitDCameraSourceDev();
     int32_t ret = camDev_->DCameraNotify(TEST_EVENT_CMD_JSON);
     EXPECT_EQ(DCAMERA_OK, ret);
@@ -172,6 +176,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_004, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_005, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
     index.dhId_ = TEST_CAMERA_DH_ID_0;
@@ -188,6 +193,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_005, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_006, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
     index.dhId_ = TEST_CAMERA_DH_ID_0;
@@ -204,6 +210,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_006, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_007, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
     std::shared_ptr<DCStreamInfo> streamInfo = std::make_shared<DCStreamInfo>();
     streamInfo->streamId_ = 1;
@@ -228,6 +235,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_007, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_008, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
     std::vector<int> streamIds;
     int streamId = 1;
@@ -256,6 +264,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_008, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_009, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
     std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
     captureInfo->streamIds_.push_back(1);
@@ -280,6 +289,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_009, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_010, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
     std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
     int streamId = 1;
@@ -308,6 +318,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_010, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_011, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
     std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
     int streamId = 1;
@@ -342,6 +353,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_011, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_012, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
     DCameraSourceEvent event(DCAMERA_EVENT_NOFIFY, camEvent);
     camDev_->InitDCameraSourceDev();
@@ -358,6 +370,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_012, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_013, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<DCameraIndex> indexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -386,6 +399,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_013, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_014, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     camDev_->InitDCameraSourceDev();
     std::string devId = TEST_DEVICE_ID;
     std::string dhId = TEST_CAMERA_DH_ID_0;
@@ -406,6 +420,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_014, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_015, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     SetTokenID();
     std::vector<DCameraIndex> indexs;
     camDev_->InitDCameraSourceDev();
@@ -429,6 +444,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_015, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_016, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     camDev_->InitDCameraSourceDev();
     std::vector<DCameraIndex> indexs;
     DCameraIndex index;
@@ -462,6 +478,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_016, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_017, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     camDev_->InitDCameraSourceDev();
     std::vector<DCameraIndex> indexs;
     DCameraIndex index;
@@ -502,6 +519,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_017, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_018, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     camDev_->InitDCameraSourceDev();
     std::vector<DCameraIndex> indexs;
     DCameraIndex index;
@@ -523,6 +541,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_018, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_019, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
     std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
     captureInfo->streamIds_.push_back(1);
@@ -558,6 +577,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_019, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_020, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
     std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
     captureInfo->streamIds_.push_back(1);
@@ -598,6 +618,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_020, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_021, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
     std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
     int streamId = 1;
@@ -637,6 +658,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_021, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_022, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     int32_t ret = camDev_->InitDCameraSourceDev();
     int32_t result = 0;
     DCAMERA_EVENT eventType = DCAMERA_EVENT::DCAMERA_EVENT_OPEN;
@@ -656,6 +678,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_022, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceDevTest, SetHicollieFlag_001, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
     camDev_->SetHicollieFlag(true);
     EXPECT_EQ(true, camDev_->GetHicollieFlag());
     camDev_->SetHicollieFlag(false);
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_input_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_input_test.cpp
index 1b40d05609a5c6676593e795e937d10a10810e75..71ffde18c6545fa1bc7249833027da656f3a8915 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_input_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_input_test.cpp
@@ -321,6 +321,7 @@ HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_009, TestSize.Level1)
     int32_t rc = testInput_->Init();
     EXPECT_EQ(rc, DCAMERA_OK);
 
+    EXPECT_NE(nullptr, camDev_);
     rc = camDev_->InitDCameraSourceDev();
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -342,7 +343,7 @@ HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_010, TestSize.Level1)
 
     int32_t rc = testInput_->Init();
     EXPECT_EQ(rc, DCAMERA_OK);
-
+    EXPECT_NE(nullptr, camDev_);
     rc = camDev_->InitDCameraSourceDev();
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -383,6 +384,7 @@ HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_011, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_012, TestSize.Level1)
 {
+    EXPECT_EQ(false, testInput_ == nullptr);
     int32_t rc = testInput_->Init();
     std::vector<std::shared_ptr<DataBuffer>> buffers;
     size_t capacity = 1;
@@ -400,6 +402,8 @@ HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_012, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_014, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, camDev_);
+    EXPECT_EQ(false, testInput_ == nullptr);
     int32_t rc = testInput_->Init();
     rc = camDev_->InitDCameraSourceDev();
     EXPECT_EQ(rc, DCAMERA_OK);
@@ -416,6 +420,8 @@ HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_014, TestSize.Level1)
  */
 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_015, TestSize.Level1)
 {
+    EXPECT_EQ(false, testInput_ == nullptr);
+    EXPECT_NE(nullptr, camDev_);
     int32_t rc = testInput_->Init();
     rc = camDev_->InitDCameraSourceDev();
     EXPECT_EQ(rc, DCAMERA_OK);
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_service_ipc_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_service_ipc_test.cpp
index 0a22b70ce55557413680e02a971e6b37d67de90f..4a7d780ae229f29fd9e0821a9d0e575e37a32bc2 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_service_ipc_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_service_ipc_test.cpp
@@ -142,6 +142,7 @@ HWTEST_F(DCameraSourceServiceIpcTest, dcamera_source_service_ipc_test_005, TestS
     DCameraSourceServiceIpc::GetInstance().Init();
     sptr<ISystemAbilityManager> samgr =
             SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    EXPECT_NE(nullptr, samgr);
     wptr<IRemoteObject> remote = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID);
     DCameraSourceServiceIpc::GetInstance().OnSinkRemoteCamSrvDied(remote);
     DCameraSourceServiceIpc::GetInstance().UnInit();
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp
index 52b49292dadaa9fed926c408f9cffa646f84d011..996fa3980a1000db392324b4c4a02b0a2a3e2e60 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp
@@ -174,13 +174,14 @@ void DCameraSourceStateMachineTest::TearDown(void)
  */
 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_001, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, stateMachine_);
     DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
     DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
-    int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
+    stateMachine_->UpdateState(DCAMERA_STATE_INIT);
+    int32_t ret = stateMachine_->Execute(DCAMERA_EVENT_REGIST, event0);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_UNREGIST, event1);
     EXPECT_EQ(DCAMERA_OK, ret);
 }
 
@@ -192,26 +193,27 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_001, T
  */
 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_002, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, stateMachine_);
     DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
     DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
     DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
     DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex);
     DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
-    int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
+    stateMachine_->UpdateState(DCAMERA_STATE_INIT);
+    stateMachine_->UpdateState(DCAMERA_STATE_REGIST);
+    int32_t ret = stateMachine_->Execute(DCAMERA_EVENT_REGIST, event0);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_OPEN, event2);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_CLOSE, event3);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_NOFIFY, event9);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_UNREGIST, event1);
     EXPECT_EQ(DCAMERA_OK, ret);
 }
 
@@ -223,6 +225,7 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_002, T
  */
 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_003, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, stateMachine_);
     DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
     DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
     DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
@@ -231,31 +234,31 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_003, T
     DCameraSourceEvent event5(DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap);
     DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
     DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
-    int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
+    stateMachine_->UpdateState(DCAMERA_STATE_INIT);
+    stateMachine_->UpdateState(DCAMERA_STATE_REGIST);
+    stateMachine_->UpdateState(DCAMERA_STATE_OPENED);
+    int32_t ret = stateMachine_->Execute(DCAMERA_EVENT_REGIST, event0);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_OPEN, event2);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event4);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event4);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event5);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event5);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_NOFIFY, event9);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_CLOSE, event3);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_UNREGIST, event1);
     EXPECT_EQ(DCAMERA_OK, ret);
 }
 
@@ -267,6 +270,7 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_003, T
  */
 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_004, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, stateMachine_);
     DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
     DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
     DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
@@ -277,38 +281,38 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_004, T
     DCameraSourceEvent event7(DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
     DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
     DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
-    int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
+    stateMachine_->UpdateState(DCAMERA_STATE_INIT);
+    stateMachine_->UpdateState(DCAMERA_STATE_REGIST);
+    stateMachine_->UpdateState(DCAMERA_STATE_OPENED);
+    stateMachine_->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
+    int32_t ret = stateMachine_->Execute(DCAMERA_EVENT_REGIST, event0);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_OPEN, event2);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event4);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event4);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_START_CAPTURE, event6);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_START_CAPTURE, event6);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_NOFIFY, event9);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_STOP_CAPTURE, event7);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_STOP_CAPTURE, event7);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event5);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event5);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_CLOSE, event3);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_UNREGIST, event1);
     EXPECT_EQ(DCAMERA_OK, ret);
 }
 
@@ -320,6 +324,7 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_004, T
  */
 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_005, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, stateMachine_);
     DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
     DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
     DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
@@ -328,33 +333,33 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_005, T
     DCameraSourceEvent event7(DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
     DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
     DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
-    stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
-    int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
+    stateMachine_->UpdateState(DCAMERA_STATE_INIT);
+    stateMachine_->UpdateState(DCAMERA_STATE_REGIST);
+    stateMachine_->UpdateState(DCAMERA_STATE_OPENED);
+    stateMachine_->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
+    stateMachine_->UpdateState(DCAMERA_STATE_CAPTURE);
+    int32_t ret = stateMachine_->Execute(DCAMERA_EVENT_REGIST, event0);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_OPEN, event2);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_START_CAPTURE, event6);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_START_CAPTURE, event6);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_NOFIFY, event9);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_STOP_CAPTURE, event7);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_STOP_CAPTURE, event7);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_CLOSE, event3);
     EXPECT_EQ(DCAMERA_OK, ret);
 
-    ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
+    ret = stateMachine_->Execute(DCAMERA_EVENT_UNREGIST, event1);
     EXPECT_EQ(DCAMERA_OK, ret);
 }
 } // namespace DistributedHardware