diff --git a/services/camera_service/include/hcamera_service.h b/services/camera_service/include/hcamera_service.h
index 2c78aeb133d7f06599fc92b84bafb612ba0adb4f..38987a6ee9e5221e7a781a3882ea6182570074b7 100644
--- a/services/camera_service/include/hcamera_service.h
+++ b/services/camera_service/include/hcamera_service.h
@@ -207,6 +207,16 @@ public:
     int32_t GetCameraStorageSize(int64_t& size) override;
     int32_t CallbackEnter([[maybe_unused]] uint32_t code) override;
     int32_t CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result) override;
+    inline void SetSessionForControlCenter(sptr<HCaptureSession> session)
+    {
+        std::lock_guard<std::mutex> lock(videoSessionMutex_);
+        videoSessionForControlCenter_ = session;
+    }
+    inline sptr<HCaptureSession> GetSessionForControlCenter()
+    {
+        std::lock_guard<std::mutex> lock(videoSessionMutex_);
+        return videoSessionForControlCenter_;
+    }
 protected:
     explicit HCameraService(sptr<HCameraHostManager> cameraHostManager);
     void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
@@ -321,6 +331,7 @@ private:
     mutex muteCbMutex_;
     mutex serviceStatusMutex_;
     mutex controlCenterStatusMutex_;
+    mutex videoSessionMutex_;
     recursive_mutex torchCbMutex_;
     recursive_mutex foldCbMutex_;
     TorchStatus torchStatus_ = TorchStatus::TORCH_STATUS_UNAVAILABLE;
@@ -348,7 +359,7 @@ private:
     bool isFoldable = false;
     bool isFoldableInit = false;
     bool isControlCenterEnabled_ = false;
-    bool controlCenterPrecondition = true;
+    std::atomic<bool> controlCenterPrecondition = true;
     bool deviceControlCenterAbility = false;
     string preCameraId_;
     string preCameraClient_;
diff --git a/services/camera_service/src/hcamera_service.cpp b/services/camera_service/src/hcamera_service.cpp
index dc96189140e0e6c3fce1bf501436543b520695f0..68e862060fc9e048034278e501a491f5359d644e 100644
--- a/services/camera_service/src/hcamera_service.cpp
+++ b/services/camera_service/src/hcamera_service.cpp
@@ -323,6 +323,9 @@ int32_t HCameraService::GetControlCenterStatusFromDataShareHelper(bool &status)
     lock_guard<mutex> lock(g_dataShareHelperMutex);
     CHECK_RETURN_RET_ELOG(cameraDataShareHelper_ == nullptr, CAMERA_INVALID_ARG,
         "GetControlCenterStatusFromDataShareHelper NULL");
+    sptr<HCaptureSession> sessionForControlCenter = GetSessionForControlCenter();
+    CHECK_RETURN_RET_ELOG(sessionForControlCenter == nullptr, CAMERA_INVALID_STATE,
+        "GetControlCenterStatusFromDataShareHelper failed, not in video session.");
     
     std::string value = "";
     auto ret = cameraDataShareHelper_->QueryOnce(CONTROL_CENTER_DATA, value);
@@ -334,7 +337,7 @@ int32_t HCameraService::GetControlCenterStatusFromDataShareHelper(bool &status)
         return CAMERA_OK;
     }
 
-    std::string bundleName = videoSessionForControlCenter_->GetBundleForControlCenter();
+    std::string bundleName = sessionForControlCenter->GetBundleForControlCenter();
     std::map<std::string, std::array<float, CONTROL_CENTER_DATA_SIZE>> controlCenterMap
         = StringToControlCenterMap(value);
     if (controlCenterMap.find(bundleName) != controlCenterMap.end()) {
@@ -365,10 +368,13 @@ int32_t HCameraService::UpdateDataShareAndTag(bool status, bool needPersistEnabl
 {
     MEDIA_INFO_LOG("HCameraService::UpdateDataShareAndTag");
     lock_guard<mutex> lock(g_dataShareHelperMutex);
+    sptr<HCaptureSession> sessionForControlCenter = GetSessionForControlCenter();
     CHECK_RETURN_RET_ELOG(cameraDataShareHelper_ == nullptr, CAMERA_ALLOC_ERROR,
         "GetMuteModeFromDataShareHelper NULL");
+    CHECK_RETURN_RET_ELOG(sessionForControlCenter == nullptr, CAMERA_INVALID_STATE,
+        "GetControlCenterStatusFromDataShareHelper failed, not in video session.");
 
-    std::string bundleName = videoSessionForControlCenter_->GetBundleForControlCenter();
+    std::string bundleName = sessionForControlCenter->GetBundleForControlCenter();
     std::map<std::string, std::array<float, CONTROL_CENTER_DATA_SIZE>> controlCenterMap;
     std::string value = "";
     auto ret = cameraDataShareHelper_->QueryOnce(CONTROL_CENTER_DATA, value);
@@ -388,13 +394,13 @@ int32_t HCameraService::UpdateDataShareAndTag(bool status, bool needPersistEnabl
             MEDIA_INFO_LOG("UpdateDataShareAndTag ret:  %{public}d", ret);
         }
         if (status) {
-            videoSessionForControlCenter_->SetBeautyValue(
+            sessionForControlCenter->SetBeautyValue(
                 BeautyType::AUTO_TYPE, controlCenterMap[bundleName][CONTROL_CENTER_BEAUTY_INDEX], false);
-            videoSessionForControlCenter_->SetVirtualApertureValue(
+            sessionForControlCenter->SetVirtualApertureValue(
                 controlCenterMap[bundleName][CONTROL_CENTER_APERTURE_INDEX], false);
         } else if (needPersistEnable) {
-            videoSessionForControlCenter_->SetBeautyValue(BeautyType::AUTO_TYPE, 0, false);
-            videoSessionForControlCenter_->SetVirtualApertureValue(0, false);
+            sessionForControlCenter->SetBeautyValue(BeautyType::AUTO_TYPE, 0, false);
+            sessionForControlCenter->SetVirtualApertureValue(0, false);
         }
     } else {
         MEDIA_INFO_LOG("UpdateDataShareAndTag no bundle, create info for new bundle.");
@@ -406,8 +412,11 @@ int32_t HCameraService::UpdateDataShareAndTag(bool status, bool needPersistEnabl
 int32_t HCameraService::CreateControlCenterDataShare(std::map<std::string,
     std::array<float, CONTROL_CENTER_DATA_SIZE>> controlCenterMap, std::string bundleName, bool status)
 {
+    sptr<HCaptureSession> sessionForControlCenter = GetSessionForControlCenter();
+    CHECK_RETURN_RET_ELOG(sessionForControlCenter == nullptr, CAMERA_INVALID_STATE,
+        "CreateControlCenterDataShare failed, not in video session.");
     std::vector<float> virtualMetadata = {};
-    videoSessionForControlCenter_->GetVirtualApertureMetadate(virtualMetadata);
+    sessionForControlCenter->GetVirtualApertureMetadate(virtualMetadata);
     float biggestAperture = 0;
     CHECK_EXECUTE(virtualMetadata.size() > 0, biggestAperture = virtualMetadata.back());
 
@@ -416,11 +425,11 @@ int32_t HCameraService::CreateControlCenterDataShare(std::map<std::string,
     auto ret = cameraDataShareHelper_->UpdateOnce(CONTROL_CENTER_DATA, controlCenterString);
     CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, ret, "CreateControlCenterDataShare failed.");
 
-    videoSessionForControlCenter_->SetBeautyValue(BeautyType::AUTO_TYPE, 0, false);
+    sessionForControlCenter->SetBeautyValue(BeautyType::AUTO_TYPE, 0, false);
     if (status) {
-        videoSessionForControlCenter_->SetVirtualApertureValue(biggestAperture, false);
+        sessionForControlCenter->SetVirtualApertureValue(biggestAperture, false);
     } else {
-        videoSessionForControlCenter_->SetVirtualApertureValue(0, false);
+        sessionForControlCenter->SetVirtualApertureValue(0, false);
     }
     return ret;
 }
@@ -694,14 +703,14 @@ int32_t HCameraService::CreateCaptureSession(sptr<ICaptureSession>& session, int
     }
     session = captureSession;
     if (opMode == SceneMode::VIDEO) {
-        videoSessionForControlCenter_ = captureSession;
-        videoSessionForControlCenter_->SetUpdateControlCenterCallback(
+        SetSessionForControlCenter(captureSession);
+        captureSession->SetUpdateControlCenterCallback(
             std::bind(&HCameraService::UpdateControlCenterStatus, this, std::placeholders::_1));
         std::string bundleName = BmsAdapter::GetInstance()->GetBundleName(IPCSkeleton::GetCallingUid());
-        videoSessionForControlCenter_->SetBundleForControlCenter(bundleName);
+        captureSession->SetBundleForControlCenter(bundleName);
         MEDIA_INFO_LOG("Save videoSession for controlCenter");
     } else {
-        videoSessionForControlCenter_ = nullptr;
+        SetSessionForControlCenter(nullptr);
         MEDIA_INFO_LOG("Clear videoSession of controlCenter");
     }
 
@@ -727,11 +736,12 @@ int32_t HCameraService::GetVideoSessionForControlCenter(sptr<ICaptureSession>& s
 {
     std::lock_guard<std::mutex> lock(mutex_);
     MEDIA_INFO_LOG("HCameraService::GetVideoSessionForControlCenter");
-    if (videoSessionForControlCenter_ == nullptr) {
+    sptr<HCaptureSession> sessionForControlCenter = GetSessionForControlCenter();
+    if (sessionForControlCenter == nullptr) {
         MEDIA_ERR_LOG("GetVideoSessionForControlCenter failed, session == nullptr.");
         return CAMERA_INVALID_ARG;
     }
-    session = videoSessionForControlCenter_;
+    session = sessionForControlCenter;
     return CAMERA_OK;
 }
 
@@ -1555,19 +1565,18 @@ int32_t HCameraService::EnableControlCenter(bool status, bool needPersistEnable)
 
 int32_t HCameraService::SetControlCenterPrecondition(bool condition)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
     MEDIA_INFO_LOG("HCameraService::SetControlCenterPrecondition %{public}d", condition);
+    sptr<HCaptureSession> sessionForControlCenter = GetSessionForControlCenter();
     controlCenterPrecondition = condition;
-    if (videoSessionForControlCenter_ != nullptr) {
-        videoSessionForControlCenter_->SetControlCenterPrecondition(controlCenterPrecondition);
-    } else {
-        MEDIA_WARNING_LOG("");
+    if (sessionForControlCenter != nullptr) {
+        sessionForControlCenter->SetControlCenterPrecondition(controlCenterPrecondition);
     }
     CHECK_RETURN_RET_DLOG(controlCenterPrecondition || !isControlCenterEnabled_, CAMERA_OK,
         "SetControlCenterPrecondition success.");
     auto ret = EnableControlCenter(false, true);
     CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, ret, "EnableControlCenter failed.");
     isControlCenterEnabled_ = false;
+    lock_guard<mutex> lock(controlCenterStatusMutex_);
     for (auto it : controlcenterCallbacks_) {
         if (it.second == nullptr) {
             MEDIA_ERR_LOG("OnControlCenterStatusChanged pid:%{public}d Callbacks is null", it.first);
@@ -1584,10 +1593,10 @@ int32_t HCameraService::SetControlCenterPrecondition(bool condition)
 
 int32_t HCameraService::SetDeviceControlCenterAbility(bool ability)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    sptr<HCaptureSession> sessionForControlCenter = GetSessionForControlCenter();
     deviceControlCenterAbility = ability;
-    if (videoSessionForControlCenter_ != nullptr) {
-        videoSessionForControlCenter_->SetDeviceControlCenterAbility(ability);
+    if (sessionForControlCenter != nullptr) {
+        sessionForControlCenter->SetDeviceControlCenterAbility(ability);
     }
     return CAMERA_OK;
 }