diff --git a/services/audio/include/audio_control_manager.h b/services/audio/include/audio_control_manager.h
index c5e5331f35d57691f24b8fd50cf22292a446f1f9..a6d1db6b761ba00283ee456ac0cf72d53b8c08e5 100644
--- a/services/audio/include/audio_control_manager.h
+++ b/services/audio/include/audio_control_manager.h
@@ -31,6 +31,9 @@
 
 namespace OHOS {
 namespace Telephony {
+static constexpr const char *VIDEO_RING_PATH_FIX_TAIL = ".mp4";
+constexpr int32_t VIDEO_RING_PATH_FIX_TAIL_LENGTH = 4;
+static constexpr const char *SYSTEM_VIDEO_RING = "system_video_ring";
 class AudioControlManager : public CallStateListenerBase, public std::enable_shared_from_this<AudioControlManager> {
     DECLARE_DELAYED_SINGLETON(AudioControlManager)
 
@@ -93,6 +96,7 @@ public:
     bool IsScoTemporarilyDisabled();
     void ExcludeBluetoothSco();
     void UnexcludeBluetoothSco();
+    bool IsVideoRing(const std::string &personalNotificationRingtone, const std::string &ringtonePath);
 
 private:
     RingState ringState_ = RingState::STOPPED;
@@ -105,6 +109,7 @@ private:
     sptr<CallBase> GetCallBase(int32_t callId);
     AudioInterruptState audioInterruptState_ = AudioInterruptState::INTERRUPT_STATE_DEACTIVATED;
     bool ShouldPlayRingtone() const;
+    bool CheckAndDealVideoRingScene(const std::string &personalNotificationRingtone, const std::string &ringtonePath);
     bool IsEmergencyCallExists();
     void UpdateForegroundLiveCall();
     bool IsBtOrWireHeadPlugin();
@@ -124,6 +129,7 @@ private:
     SoundState soundState_ = SoundState::STOPPED;
     bool isLocalRingbackNeeded_ = false;
     bool isCrsVibrating_ = false;
+    bool isVideoRingVibrating_ = false;
     std::set<sptr<CallBase>> totalCalls_;
     std::unique_ptr<Ring> ring_;
     std::unique_ptr<Tone> tone_;
diff --git a/services/audio/src/audio_control_manager.cpp b/services/audio/src/audio_control_manager.cpp
index d8dc423ef1a6aef5bf5adcbe34014bed514fe54c..940b161a344d2dac4406fd6aa3924cb4f3dd9328 100644
--- a/services/audio/src/audio_control_manager.cpp
+++ b/services/audio/src/audio_control_manager.cpp
@@ -346,6 +346,10 @@ void AudioControlManager::HandleNextState(sptr<CallBase> &callObjectPtr, TelCall
                 DelayedSingleton<AudioProxy>::GetInstance()->StopVibrator();
                 isCrsVibrating_ = false;
             }
+            if (isVideoRingVibrating_) {
+                DelayedSingleton<AudioProxy>::GetInstance()->StopVibrator();
+                isVideoRingVibrating_ = false;
+            }
             audioInterruptState_ = AudioInterruptState::INTERRUPT_STATE_DEACTIVATED;
             break;
         default:
@@ -409,6 +413,10 @@ void AudioControlManager::ProcessAudioWhenCallActive(sptr<CallBase> &callObjectP
             DelayedSingleton<AudioProxy>::GetInstance()->StopVibrator();
             isCrsVibrating_ = false;
         }
+        if (isVideoRingVibrating_) {
+            DelayedSingleton<AudioProxy>::GetInstance()->StopVibrator();
+            isVideoRingVibrating_ = false;
+        }
         int ringCallCount = CallObjectManager::GetCallNumByRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
         if ((CallObjectManager::GetCurrentCallNum() - ringCallCount) < MIN_MULITY_CALL_COUNT) {
             StopSoundtone();
@@ -600,7 +608,9 @@ bool AudioControlManager::PlayRingtone()
         TELEPHONY_LOGI("type_crs but not play ringtone");
         return false;
     }
-
+    if (CheckAndDealVideoRingScene(contactInfo.personalNotificationRingtone, contactInfo.ringtonePath)) {
+        return false;
+    }
     if (incomingCall->GetCallType() == CallType::TYPE_BLUETOOTH) {
         ret = ring_->Play(info.accountId, contactInfo.ringtonePath, Media::HapticStartupMode::FAST);
     } else {
@@ -619,6 +629,34 @@ bool AudioControlManager::PlayRingtone()
     return true;
 }
 
+bool AudioControlManager::IsVideoRing(const std::string &personalNotificationRingtone, const std::string &ringtonePath)
+{
+    if ((personalNotificationRingtone.length() > VIDEO_RING_PATH_FIX_TAIL_LENGTH &&
+        personalNotificationRingtone.substr(personalNotificationRingtone.length() - VIDEO_RING_PATH_FIX_TAIL_LENGTH,
+        VIDEO_RING_PATH_FIX_TAIL_LENGTH) == VIDEO_RING_PATH_FIX_TAIL) || ringtonePath == SYSTEM_VIDEO_RING) {
+        TELEPHONY_LOGI("Is video ring.");
+        return true;
+    }
+    return false;
+}
+
+bool AudioControlManager::CheckAndDealVideoRingScene(const std::string &personalNotificationRingtone,
+    const std::string &ringtonePath)
+{
+    if (IsVideoRing(personalNotificationRingtone, ringtonePath)) {
+        TELEPHONY_LOGI("video ring scene.");
+        AudioStandard::AudioRingerMode ringMode = DelayedSingleton<AudioProxy>::GetInstance()->GetRingerMode();
+        if ((ringMode == AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL && IsRingingVibrateModeOn()) ||
+            ringMode == AudioStandard::AudioRingerMode::RINGER_MODE_VIBRATE) {
+            TELEPHONY_LOGI("need start vibrator.");
+            isVideoRingVibrating_ = (DelayedSingleton<AudioProxy>::GetInstance()->StartVibrator() == TELEPHONY_SUCCESS);
+        }
+        return true;
+    }
+    TELEPHONY_LOGI("audio ring scene.");
+    return false;
+}
+
 bool AudioControlManager::IsDistributeCallSinkStatus()
 {
     std::string dcStatus = "";
@@ -954,6 +992,7 @@ bool AudioControlManager::ShouldPlayRingtone() const
     int32_t incomingCallNum = processor->GetCallNumber(TelCallState::CALL_STATUS_INCOMING);
     if (incomingCallNum == EMPTY_VALUE || alertingCallNum > EMPTY_VALUE || ringState_ == RingState::RINGING
         || (soundState_ == SoundState::SOUNDING && CallObjectManager::HasIncomingCallCrsType())) {
+        TELEPHONY_LOGI("should not play ring tone.");
         return false;
     }
     return true;
@@ -1107,6 +1146,10 @@ void AudioControlManager::MuteNetWorkRingTone()
         DelayedSingleton<AudioProxy>::GetInstance()->StopVibrator();
         isCrsVibrating_ = false;
     }
+    if (isVideoRingVibrating_) {
+        DelayedSingleton<AudioProxy>::GetInstance()->StopVibrator();
+        isVideoRingVibrating_ = false;
+    }
 }
 
 bool AudioControlManager::IsVideoCall(VideoStateType videoState)
diff --git a/services/call/call_state_observer/include/call_data_base_helper.h b/services/call/call_state_observer/include/call_data_base_helper.h
index e87e9952d2acb52d1b88c08c67092c3facabbb78..f5555ebba1cb10e06c1584354e465a41d8802ec9 100644
--- a/services/call/call_state_observer/include/call_data_base_helper.h
+++ b/services/call/call_state_observer/include/call_data_base_helper.h
@@ -67,6 +67,7 @@ constexpr const char *CALL_MARK_DETAILS = "mark_details";
 constexpr const char *CALL_DETECT_DETAILS = "detect_details";
 constexpr const char *CALL_IS_CNAP = "is_cnap";
 constexpr const char *PERSONAL_RINGTONE = "personal_ringtone";
+constexpr const char *PERSONAL_NOTIFICATION_RINGTONE = "personal_notification_ringtone";
 
 enum class CallLogReadState {
     CALL_IS_UNREAD,
diff --git a/services/call/call_state_observer/src/call_data_base_helper.cpp b/services/call/call_state_observer/src/call_data_base_helper.cpp
index c4a2a063710609a3f03241994ba645ebd87f26da..91259b13ee793fd33d8fc30ee5f6ada5895100de 100644
--- a/services/call/call_state_observer/src/call_data_base_helper.cpp
+++ b/services/call/call_state_observer/src/call_data_base_helper.cpp
@@ -187,19 +187,19 @@ bool CallDataBaseHelper::Query(ContactInfo &contactInfo, DataShare::DataSharePre
     Uri uri(CONTACT_DATA);
     std::vector<std::string> columns;
     auto resultSet = helper->Query(uri, predicates, columns);
+    helper->Release();
     if (!CheckResultSet(resultSet)) {
         TELEPHONY_LOGE("resultSet is null");
-        helper->Release();
         return false;
     }
     if (resultSet->GoToFirstRow() != E_OK) {
         TELEPHONY_LOGE("GoToFirstRow failed");
         resultSet->Close();
-        helper->Release();
         return false;
     }
     int32_t columnIndex;
     std::string ringtonePath = "";
+    std::string personalNotificationRingtone = "";
     resultSet->GetColumnIndex(CALL_DISPLAY_NAME, columnIndex);
     resultSet->GetString(columnIndex, contactInfo.name);
     resultSet->GetColumnIndex(PERSONAL_RINGTONE, columnIndex);
@@ -207,11 +207,20 @@ bool CallDataBaseHelper::Query(ContactInfo &contactInfo, DataShare::DataSharePre
     uint32_t length = ringtonePath.length() > FILE_PATH_MAX_LEN ? FILE_PATH_MAX_LEN : ringtonePath.length();
     if (memcpy_s(contactInfo.ringtonePath, FILE_PATH_MAX_LEN, ringtonePath.c_str(), length) != EOK) {
         TELEPHONY_LOGE("memcpy_s ringtonePath fail!");
+        resultSet->Close();
         return false;
     }
     TELEPHONY_LOGI("ringtonePath: %{public}s", contactInfo.ringtonePath);
+    resultSet->GetColumnIndex(PERSONAL_NOTIFICATION_RINGTONE, columnIndex);
+    resultSet->GetString(columnIndex, personalNotificationRingtone);
     resultSet->Close();
-    helper->Release();
+    length = personalNotificationRingtone.length() > FILE_PATH_MAX_LEN ?
+        FILE_PATH_MAX_LEN : personalNotificationRingtone.length();
+    if (memcpy_s(contactInfo.personalNotificationRingtone, FILE_PATH_MAX_LEN, personalNotificationRingtone.c_str(),
+        length) != EOK) {
+        TELEPHONY_LOGE("memcpy_s personalNotificationRingtone fail!");
+        return false;
+    }
     TELEPHONY_LOGI("Query end, contactName length: %{public}zu", contactInfo.name.length());
     return true;
 }
@@ -451,9 +460,9 @@ bool CallDataBaseHelper::QueryContactInfoEnhanced(ContactInfo &contactInfo, Data
     Uri uri(CONTACT_DATA);
     std::vector<std::string> columns;
     auto resultSet = helper->Query(uri, predicates, columns);
+    helper->Release();
     if (!CheckResultSet(resultSet)) {
         TELEPHONY_LOGE("resultSet is null!");
-        helper->Release();
         return false;
     }
     int resultId = GetCallerIndex(resultSet, contactInfo.number);
@@ -461,11 +470,11 @@ bool CallDataBaseHelper::QueryContactInfoEnhanced(ContactInfo &contactInfo, Data
     if (resultSet->GoToRow(resultId) != E_OK) {
         TELEPHONY_LOGE("GoToRow failed");
         resultSet->Close();
-        helper->Release();
         return false;
     }
     int32_t columnIndex;
     std::string ringtonePath = "";
+    std::string personalNotificationRingtone = "";
     resultSet->GetColumnIndex(CALL_DISPLAY_NAME, columnIndex);
     resultSet->GetString(columnIndex, contactInfo.name);
     resultSet->GetColumnIndex(PERSONAL_RINGTONE, columnIndex);
@@ -473,11 +482,20 @@ bool CallDataBaseHelper::QueryContactInfoEnhanced(ContactInfo &contactInfo, Data
     uint32_t length = ringtonePath.length() > FILE_PATH_MAX_LEN ? FILE_PATH_MAX_LEN : ringtonePath.length();
     if (memcpy_s(contactInfo.ringtonePath, FILE_PATH_MAX_LEN, ringtonePath.c_str(), length) != EOK) {
         TELEPHONY_LOGE("memcpy_s ringtonePath fail!");
+        resultSet->Close();
         return false;
     }
     TELEPHONY_LOGI("ringtonePath: %{public}s", contactInfo.ringtonePath);
+    resultSet->GetColumnIndex(PERSONAL_NOTIFICATION_RINGTONE, columnIndex);
+    resultSet->GetString(columnIndex, personalNotificationRingtone);
     resultSet->Close();
-    helper->Release();
+    length = personalNotificationRingtone.length() > FILE_PATH_MAX_LEN ?
+        FILE_PATH_MAX_LEN : personalNotificationRingtone.length();
+    if (memcpy_s(contactInfo.personalNotificationRingtone, FILE_PATH_MAX_LEN, personalNotificationRingtone.c_str(),
+        length) != EOK) {
+        TELEPHONY_LOGE("memcpy_s personalNotificationRingtone fail!");
+        return false;
+    }
     TELEPHONY_LOGI("Query end, contactName length: %{public}zu", contactInfo.name.length());
     return true;
 }
diff --git a/services/call/include/call_status_manager.h b/services/call/include/call_status_manager.h
index 0b19cd9c98f2ffa8a5ca6558cf9f6ea7114c498c..de00593c52421316e4afea3f82628793b8ce5dd2 100644
--- a/services/call/include/call_status_manager.h
+++ b/services/call/include/call_status_manager.h
@@ -107,6 +107,8 @@ private:
     bool IsContactPhoneNum(const std::string &phoneNum);
     int32_t UpdateDialingCallInfo(const CallDetailInfo &info);
     void SetContactInfo(sptr<CallBase> &call, std::string phoneNum);
+    void DealVideoRingPath(ContactInfo &ringtonePath, sptr<CallBase> &callObjectPtr);
+    int32_t QuerySystemVideoConfig(sptr<CallBase> &callObjectPtr, ContactInfo &contactInfo);
     int32_t HandleRejectCall(sptr<CallBase> &call, bool isBlock);
     bool ShouldRejectIncomingCall();
     bool ShouldBlockIncomingCall(const sptr<CallBase> &call, const CallDetailInfo &info);
diff --git a/services/call/include/common_type.h b/services/call/include/common_type.h
index b66adc6e5e01d4cecde695fac283d081a06876cd..50a78bf9258d73e5695b482400c17de004960a20 100644
--- a/services/call/include/common_type.h
+++ b/services/call/include/common_type.h
@@ -85,6 +85,7 @@ struct ContactInfo {
     std::string number = "";
     bool isContacterExists = false;
     char ringtonePath[FILE_PATH_MAX_LEN] = { 0 };
+    char personalNotificationRingtone[FILE_PATH_MAX_LEN] = { 0 };
     bool isSendToVoicemail = false;
     bool isEcc = false;
     bool isVoiceMail = false;
diff --git a/services/call/src/call_status_manager.cpp b/services/call/src/call_status_manager.cpp
index ada1665e4f1e2882ddd65ea101f8a6512ee9e915..ce595110bfb6a63f7cef0d25fc08300784676e1d 100644
--- a/services/call/src/call_status_manager.cpp
+++ b/services/call/src/call_status_manager.cpp
@@ -59,6 +59,8 @@
 namespace OHOS {
 namespace Telephony {
 constexpr int32_t INIT_INDEX = 0;
+constexpr int32_t RING_TYPE_AUDIO = 0;
+constexpr int32_t RING_TYPE_VIDEO = 1;
 constexpr int32_t PRESENTATION_RESTRICTED = 3;
 
 CallStatusManager::CallStatusManager()
@@ -513,6 +515,7 @@ void CallStatusManager::SetContactInfo(sptr<CallBase> &call, std::string phoneNu
         // Get the contact data from the database
         ContactInfo contactInfoTemp = contactInfo;
         QueryCallerInfo(contactInfoTemp, phoneNum);
+        DealVideoRingPath(contactInfoTemp, callObjectPtr);
         callObjectPtr->SetCallerInfo(contactInfoTemp);
         CallVoiceAssistantManager::GetInstance()->UpdateContactInfo(contactInfoTemp, callObjectPtr->GetCallID());
         DelayedSingleton<DistributedCommunicationManager>::GetInstance()->ProcessCallInfo(callObjectPtr,
@@ -520,6 +523,74 @@ void CallStatusManager::SetContactInfo(sptr<CallBase> &call, std::string phoneNu
     });
 }
 
+void CallStatusManager::DealVideoRingPath(ContactInfo &contactInfo, sptr<CallBase> &callObjectPtr)
+{
+    bool isStartBroadcast = CallVoiceAssistantManager::GetInstance()->IsStartVoiceBroadcast();
+    if (isStartBroadcast) {
+        TELEPHONY_LOGI("Incoming call broadcast is on.");
+        return;
+    }
+
+    if (!strlen(contactInfo.ringtonePath)) {
+        int32_t result = QuerySystemVideoConfig(callObjectPtr, contactInfo);
+        if (result != TELEPHONY_SUCCESS) {
+            return;
+        }
+    }
+
+    if (DelayedSingleton<AudioControlManager>::GetInstance()->IsVideoRing(contactInfo.personalNotificationRingtone,
+        contactInfo.ringtonePath)) {
+        TELEPHONY_LOGI("notify callui to play video ring.");
+        AAFwk::WantParams params = callObjectPtr->GetExtraParams();
+        params.SetParam("VideoRingPath", AAFwk::String::Box(std::string(contactInfo.ringtonePath)));
+        callObjectPtr->SetExtraParams(params);
+    }
+}
+
+int32_t CallStatusManager::QuerySystemVideoConfig(sptr<CallBase> &callObjectPtr, ContactInfo &contactInfo)
+{
+    int32_t userId = 0;
+    bool isUserUnlocked = false;
+    AccountSA::OsAccountManager::GetForegroundOsAccountLocalId(userId);
+    AccountSA::OsAccountManager::IsOsAccountVerified(userId, isUserUnlocked);
+    TELEPHONY_LOGI("isUserUnlocked: %{public}d", isUserUnlocked);
+    if (!isUserUnlocked) {
+        return CALL_ERR_VIDEO_NOT_SUPPORTED;
+    }
+    CallAttributeInfo info;
+    callObjectPtr->GetCallAttributeBaseInfo(info);
+    auto settingHelper = SettingsDataShareHelper::GetInstance();
+    if (settingHelper == nullptr) {
+        TELEPHONY_LOGE("settingHelper is nullptr.");
+        return CALL_ERR_CALL_OBJECT_IS_NULL;
+    }
+    std::string ringtoneFlagCardKey;
+    std::string videoRingtoneNameCardKey;
+    std::string ringtoneFlagCard;
+    std::string videoRingtoneNameCard;
+    if (info.accountId == DEFAULT_SIM_SLOT_ID) {
+        ringtoneFlagCardKey = "ringtoneFlagCard1";
+        videoRingtoneNameCardKey = "videoRingtoneNameCard1";
+    } else {
+        ringtoneFlagCardKey = "ringtoneFlagCard2";
+        videoRingtoneNameCardKey = "videoRingtoneNameCard2";
+    }
+    OHOS::Uri settingUri(SettingsDataShareHelper::SETTINGS_DATASHARE_SECURE_URI_BASE + std::to_string(userId) +
+        "?Proxy=true");
+    settingHelper->QuerySecure(settingUri, ringtoneFlagCardKey, ringtoneFlagCard);
+    settingHelper->QuerySecure(settingUri, videoRingtoneNameCardKey, videoRingtoneNameCard);
+    TELEPHONY_LOGI("ringtoneFlagCard: %{public}s, videoRingtoneNameCard: %{public}s.",
+        ringtoneFlagCard.c_str(), videoRingtoneNameCard.c_str());
+    if (ringtoneFlagCard == "1" && !videoRingtoneNameCard.empty()) {
+        if (memcpy_s(contactInfo.ringtonePath, FILE_PATH_MAX_LEN, SYSTEM_VIDEO_RING,
+            strlen(SYSTEM_VIDEO_RING)) != EOK) {
+            TELEPHONY_LOGE("memcpy_s ringtonePath fail");
+            return TELEPHONY_ERROR;
+        }
+    }
+    return TELEPHONY_SUCCESS;
+}
+
 int32_t CallStatusManager::HandleRejectCall(sptr<CallBase> &call, bool isBlock)
 {
     if (call == nullptr) {
diff --git a/utils/include/settings_datashare_helper.h b/utils/include/settings_datashare_helper.h
index 78a581be3ba6e61735d7dcc05395158a902a5eec..41ad2547f440f2627b8314bc2ab7edf1d8462112 100644
--- a/utils/include/settings_datashare_helper.h
+++ b/utils/include/settings_datashare_helper.h
@@ -31,17 +31,20 @@ public:
     static const std::string QUERY_SATELLITE_MODE_KEY;
     static const std::string QUERY_SATELLITE_CONNECTED_KEY;
     static const std::string SETTINGS_DATASHARE_URI;
+    static const std::string SETTINGS_DATASHARE_SECURE_URI_BASE;
     static const std::string QUERY_MOTION_CLOSE_TO_EAR_KEY;
     static const std::string QUERY_MOTION_FLIP_MUTE_KEY;
     static const std::string QUERY_MOTION_PICKUP_REDUCE_KEY;
 
-    ErrCode Query(Uri& uri, const std::string& key, std::string& values);
+    int32_t Query(Uri& uri, const std::string& key, std::string& value);
+    int32_t QuerySecure(Uri& uri, const std::string& key, std::string& value);
     int32_t Insert(Uri &uri, const std::string &key, const std::string &value);
     int32_t Update(Uri &uri, const std::string &key, const std::string &value);
     bool RegisterToDataShare(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &observer);
     bool UnRegisterToDataShare(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &observer);
 private:
     std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int systemAbilityId);
+    std::shared_ptr<DataShare::DataShareHelper> CreateDataShareSecureHelper(int systemAbilityId);
 };
 } // namespace Telephony
 } // namespace OHOS
diff --git a/utils/src/settings_datashare_helper.cpp b/utils/src/settings_datashare_helper.cpp
index 65aa641f2d38cb02124a3770275446d33a4c6aad..b7017583274153238802a2172361cc6b7433af7d 100644
--- a/utils/src/settings_datashare_helper.cpp
+++ b/utils/src/settings_datashare_helper.cpp
@@ -23,11 +23,14 @@
 #include "telephony_log_wrapper.h"
 #include "uri.h"
 #include "singleton.h"
+#include "os_account_manager.h"
 
 namespace OHOS {
 namespace Telephony {
 const std::string SettingsDataShareHelper::SETTINGS_DATASHARE_URI =
     "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
+const std::string SettingsDataShareHelper::SETTINGS_DATASHARE_SECURE_URI_BASE =
+    "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_";
 const std::string SETTINGS_DATASHARE_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
 constexpr const char *SETTINGS_DATA_COLUMN_KEYWORD = "KEYWORD";
 constexpr const char *SETTINGS_DATA_COLUMN_VALUE = "VALUE";
@@ -57,9 +60,29 @@ std::shared_ptr<DataShare::DataShareHelper> SettingsDataShareHelper::CreateDataS
     return DataShare::DataShareHelper::Creator(remote, SETTINGS_DATASHARE_URI, SETTINGS_DATASHARE_EXT_URI);
 }
 
+std::shared_ptr<DataShare::DataShareHelper> SettingsDataShareHelper::CreateDataShareSecureHelper(
+    int systemAbilityId)
+{
+    sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (saManager == nullptr) {
+        TELEPHONY_LOGE("GetSystemAbilityManager failed.");
+        return nullptr;
+    }
+    sptr<IRemoteObject> remote = saManager->GetSystemAbility(systemAbilityId);
+    if (remote == nullptr) {
+        TELEPHONY_LOGE("GetSystemAbility Service Failed.");
+        return nullptr;
+    }
+    TELEPHONY_LOGI("systemAbilityId = %{public}d", systemAbilityId);
+    int32_t userId = 0;
+    AccountSA::OsAccountManager::GetForegroundOsAccountLocalId(userId);
+    std::string strUri = SETTINGS_DATASHARE_SECURE_URI_BASE + std::to_string(userId) + "?Proxy=true";
+    return DataShare::DataShareHelper::Creator(remote, strUri, SETTINGS_DATASHARE_EXT_URI);
+}
+
 int32_t SettingsDataShareHelper::Query(Uri& uri, const std::string& key, std::string& value)
 {
-    TELEPHONY_LOGW("start Query");
+    TELEPHONY_LOGI("start Query");
     std::shared_ptr<DataShare::DataShareHelper> settingHelper =
         CreateDataShareHelper(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
     if (settingHelper == nullptr) {
@@ -71,9 +94,9 @@ int32_t SettingsDataShareHelper::Query(Uri& uri, const std::string& key, std::st
     DataShare::DataSharePredicates predicates;
     predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
     auto result = settingHelper->Query(uri, predicates, columns);
+    settingHelper->Release();
     if (result == nullptr) {
         TELEPHONY_LOGE("query error, result is nullptr");
-        settingHelper->Release();
         return TELEPHONY_ERR_LOCAL_PTR_NULL;
     }
 
@@ -81,14 +104,12 @@ int32_t SettingsDataShareHelper::Query(Uri& uri, const std::string& key, std::st
     result->GetRowCount(rowCount);
     if (rowCount == 0) {
         TELEPHONY_LOGW("query success, but rowCount is 0");
-        settingHelper->Release();
         return TELEPHONY_ERROR;
     }
 
     if (result->GoToFirstRow() != DataShare::E_OK) {
         TELEPHONY_LOGE("query error, go to first row error");
         result->Close();
-        settingHelper->Release();
         return TELEPHONY_ERR_DATABASE_READ_FAIL;
     }
 
@@ -96,8 +117,48 @@ int32_t SettingsDataShareHelper::Query(Uri& uri, const std::string& key, std::st
     result->GetColumnIndex(SETTINGS_DATA_COLUMN_VALUE, columnIndex);
     result->GetString(columnIndex, value);
     result->Close();
+    TELEPHONY_LOGI("SettingUtils: query success");
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t SettingsDataShareHelper::QuerySecure(Uri& uri, const std::string& key, std::string& value)
+{
+    TELEPHONY_LOGI("start Query");
+    std::shared_ptr<DataShare::DataShareHelper> settingHelper =
+        CreateDataShareSecureHelper(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
+    if (settingHelper == nullptr) {
+        TELEPHONY_LOGE("query error, datashareHelper_ is nullptr");
+        return TELEPHONY_ERR_LOCAL_PTR_NULL;
+    }
+
+    std::vector<std::string> columns;
+    DataShare::DataSharePredicates predicates;
+    predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
+    auto result = settingHelper->Query(uri, predicates, columns);
     settingHelper->Release();
-    TELEPHONY_LOGW("SettingUtils: query success");
+    if (result == nullptr) {
+        TELEPHONY_LOGE("query error, result is nullptr");
+        return TELEPHONY_ERR_LOCAL_PTR_NULL;
+    }
+
+    int rowCount = 0;
+    result->GetRowCount(rowCount);
+    if (rowCount == 0) {
+        TELEPHONY_LOGW("query success, but rowCount is 0");
+        return TELEPHONY_ERROR;
+    }
+
+    if (result->GoToFirstRow() != DataShare::E_OK) {
+        TELEPHONY_LOGE("query error, go to first row error");
+        result->Close();
+        return TELEPHONY_ERR_DATABASE_READ_FAIL;
+    }
+
+    int columnIndex = 0;
+    result->GetColumnIndex(SETTINGS_DATA_COLUMN_VALUE, columnIndex);
+    result->GetString(columnIndex, value);
+    result->Close();
+    TELEPHONY_LOGI("SettingUtils: query success");
     return TELEPHONY_SUCCESS;
 }