diff --git a/frameworks/reminder/src/reminder_request.cpp b/frameworks/reminder/src/reminder_request.cpp
index 4c84c8149271df31872789a103d63716de15365b..1d94e70caad47acc51590162120fee4c94e73fce 100644
--- a/frameworks/reminder/src/reminder_request.cpp
+++ b/frameworks/reminder/src/reminder_request.cpp
@@ -888,7 +888,12 @@ void ReminderRequest::SetReminderTimeInMilli(const uint64_t reminderTimeInMilli)
 
 ReminderRequest& ReminderRequest::SetRingDuration(const uint64_t ringDurationInSeconds)
 {
-    uint64_t ringDuration = ringDurationInSeconds * MILLI_SECONDS;
+    uint64_t ringDuration = 0;
+    if (ringDurationInSeconds > (UINT64_MAX / MILLI_SECONDS)) {
+        ringDuration = 0;
+    } else {
+        ringDuration = ringDurationInSeconds * MILLI_SECONDS;
+    }
     ringDurationInMilli_ = std::min(ringDuration, MAX_RING_DURATION);
     return *this;
 }
diff --git a/frameworks/reminder/test/unittest/reminder_request_test.cpp b/frameworks/reminder/test/unittest/reminder_request_test.cpp
index 7e30e02fb1ff5ecef6fa0de81d58d8cf75ab67d6..36c620a2fa40b7c803c4296168cebf9c1dc9ec41 100644
--- a/frameworks/reminder/test/unittest/reminder_request_test.cpp
+++ b/frameworks/reminder/test/unittest/reminder_request_test.cpp
@@ -926,6 +926,20 @@ HWTEST_F(ReminderRequestTest, SetRingDuration_00003, Function | SmallTest | Leve
     EXPECT_EQ(rrc->GetRingDuration(), ReminderRequest::MAX_RING_DURATION / ReminderRequest::MILLI_SECONDS);
 }
 
+/**
+ * @tc.name: SetRingDuration_00004
+ * @tc.desc: Test SetRingDuration parameters.
+ * @tc.type: FUNC
+ * @tc.require: issueI5VB6V
+ */
+HWTEST_F(ReminderRequestTest, SetRingDuration_00004, Function | SmallTest | Level1)
+{
+    uint64_t ringDurationInSeconds = UINT64_MAX - 1;
+    auto rrc = std::make_shared<ReminderRequestChild>();
+    rrc->SetRingDuration(ringDurationInSeconds);
+    EXPECT_EQ(rrc->GetRingDuration(), 0);
+}
+
 /**
  * @tc.name: Unmarshalling_00001
  * @tc.desc: Test Unmarshalling parameters.
diff --git a/services/reminder/include/reminder_calendar_share_table.h b/services/reminder/include/reminder_calendar_share_table.h
index 33c7dc3f31e3318eb299fe1578ab29b35de33213..a85df26cca83bbce1df3ea3f91518ba2c2da536e 100644
--- a/services/reminder/include/reminder_calendar_share_table.h
+++ b/services/reminder/include/reminder_calendar_share_table.h
@@ -33,6 +33,14 @@ public:
     static constexpr const char* SLOT_TYPE = "slotType";
     static constexpr const char* KEEP_HEADSUP = "keepHeadsUp";
     static constexpr const char* IDENTIFIER = "identifier";
+    static constexpr const char* TIME_INTERVAL = "timeInterval";
+    static constexpr const char* SNOOZE_TIMES = "snoozeTimes";
+    static constexpr const char* RING_DURATION = "ringDuration";
+    static constexpr const char* SNOOZE_SLOT_TYPE = "snoozeSlotType";
+    static constexpr const char* SNOOZE_CONTENT = "snoozeContent";
+    static constexpr const char* EXPIRED_CONTENT = "expiredContent";
+    static constexpr const char* MAX_SCREEN_WANT_AGENT = "maxScreenWantAgent";
+    static constexpr const char* CUSTOM_RING_URI = "customRingUri";
 
     static constexpr const char* PROXY = "datashareproxy://com.ohos.calendardata/CalendarAlerts";
     static constexpr const char* NAME = "com.ohos.calendar";
diff --git a/services/reminder/include/reminder_datashare_helper.h b/services/reminder/include/reminder_datashare_helper.h
index 2d0435e0cfa5cc2cb19f28af1c24de4a926a6905..0e2745d956f951529456630ca81db9af5d8fcd44 100644
--- a/services/reminder/include/reminder_datashare_helper.h
+++ b/services/reminder/include/reminder_datashare_helper.h
@@ -124,6 +124,13 @@ private:
     void InitBaseInfo(const DataShare::DataShareObserver::ChangeInfo::VBucket& info,
         sptr<ReminderRequest>& reminder);
 
+    /**
+     * @brief Calendar database version1
+     */
+    void BuildReminderV1(const std::shared_ptr<DataShare::DataShareResultSet>& result,
+        sptr<ReminderRequest>& reminder);
+    void BuildReminderV1(const DataShare::DataShareObserver::ChangeInfo::VBucket& info,
+        sptr<ReminderRequest>& reminder);
 private:
     // Singleton
     ReminderDataShareHelper();
@@ -138,6 +145,7 @@ private:
     int32_t curUserId_ {0};
     int32_t uid_ {0};  // calendar
     int32_t dataUid_ {0};  // calendardata
+    bool isNewRdbVer_ = false;  // is new calendar rdb version
     std::atomic<bool> insertTask_ {false};
     std::atomic<bool> updateTask_ {false};
     std::atomic<int64_t> insertTime_ {0};
diff --git a/services/reminder/src/reminder_data_manager.cpp b/services/reminder/src/reminder_data_manager.cpp
index 93569ba02937fd86977034381382edbc1b784432..d7a9ce29cb00cf76f1823106408144a3299dc972 100644
--- a/services/reminder/src/reminder_data_manager.cpp
+++ b/services/reminder/src/reminder_data_manager.cpp
@@ -1606,13 +1606,11 @@ std::string ReminderDataManager::GetFullPath(const std::string& oriPath)
 void ReminderDataManager::PlaySoundAndVibration(const sptr<ReminderRequest> &reminder)
 {
     if (reminder == nullptr) {
-        ANSR_LOGE("Play sound and vibration failed as reminder is null.");
         return;
     }
     if (alertingReminderId_ != -1) {
         TerminateAlerting(alertingReminder_, "PlaySoundAndVibration");
     }
-    ANSR_LOGD("Play sound and vibration, reminderId=%{public}d", reminder->GetReminderId());
 #ifdef PLAYER_FRAMEWORK_ENABLE
     if (soundPlayer_ == nullptr) {
         soundPlayer_ = Media::PlayerFactory::CreatePlayer();
@@ -1633,6 +1631,10 @@ void ReminderDataManager::PlaySoundAndVibration(const sptr<ReminderRequest> &rem
         Uri defaultSound(defaultPath);
         soundPlayer_->SetSource(defaultSound.GetSchemeSpecificPart());
         ANSR_LOGI("Play default sound.");
+    } else if (customRingUri.find("file://") == 0) {
+        Uri systemSound(customRingUri);
+        soundPlayer_->SetSource(systemSound.GetSchemeSpecificPart());
+        ANSR_LOGI("Play system sound.");
     } else {
         Global::Resource::ResourceManager::RawFileDescriptor desc;
         if (GetCustomRingFileDesc(reminder, desc)) {
diff --git a/services/reminder/src/reminder_datashare_helper.cpp b/services/reminder/src/reminder_datashare_helper.cpp
index 0d31116f94049a9ca1f33db464eeae16d121be19..a6971a51e567dc5fef82c84c932141e91441fb4b 100644
--- a/services/reminder/src/reminder_datashare_helper.cpp
+++ b/services/reminder/src/reminder_datashare_helper.cpp
@@ -116,7 +116,7 @@ bool ReminderDataShareHelper::Query(std::map<std::string, sptr<ReminderRequest>>
     std::string proxy = ReminderCalendarShareTable::PROXY;
     proxy.append("?user=").append(std::to_string(curUserId_));
     Uri uri(proxy);
-    static std::vector<std::string> columns = GetColumns();
+    std::vector<std::string> columns = GetColumns();
     DataShare::DataSharePredicates predicates;
     predicates.NotEqualTo(ReminderCalendarShareTable::STATE, ReminderCalendarShareTable::STATE_DISMISSED);
     predicates.And();
@@ -185,6 +185,21 @@ void ReminderDataShareHelper::UpdateCalendarUid()
         curUserId_);
     dataUid_ = ReminderBundleManagerHelper::GetInstance()->GetDefaultUidByBundleName(
         ReminderCalendarShareTable::DATA_NAME, curUserId_);
+    AppExecFwk::BundleInfo bundleInfo;
+    if (!ReminderBundleManagerHelper::GetInstance()->GetBundleInfo(ReminderCalendarShareTable::DATA_NAME,
+        AppExecFwk::BundleFlag::GET_BUNDLE_WITH_EXTENSION_INFO, dataUid_, bundleInfo)) {
+        ANSR_LOGE("GetBundleInfo failed.");
+        return;
+    }
+    for (const auto& moduleInfo : bundleInfo.hapModuleInfos) {
+        for (const auto& metaData : moduleInfo.metadata) {
+            if (metaData.name == "hmos.calendardata.reminderDbVersion") {
+                isNewRdbVer_ = true;
+                ANSR_LOGI("New calendar rdb version.");
+                return;
+            }
+        }
+    }
 }
 
 std::map<std::string, sptr<ReminderRequest>> ReminderDataShareHelper::GetCacheReminders()
@@ -297,14 +312,29 @@ bool ReminderDataShareHelper::ReleaseDataShareHelper(const std::shared_ptr<DataS
 
 std::vector<std::string> ReminderDataShareHelper::GetColumns() const
 {
-    return std::vector<std::string> {
-        ReminderCalendarShareTable::ID, ReminderCalendarShareTable::EVENT_ID,
-        ReminderCalendarShareTable::END, ReminderCalendarShareTable::ALARM_TIME,
-        ReminderCalendarShareTable::STATE, ReminderCalendarShareTable::TITLE,
-        ReminderCalendarShareTable::CONTENT, ReminderCalendarShareTable::WANT_AGENT,
-        ReminderCalendarShareTable::BUTTONS, ReminderCalendarShareTable::SLOT_TYPE,
-        ReminderCalendarShareTable::IDENTIFIER
-    };
+    if (isNewRdbVer_) {
+        return std::vector<std::string> {
+            ReminderCalendarShareTable::ID, ReminderCalendarShareTable::EVENT_ID,
+            ReminderCalendarShareTable::END, ReminderCalendarShareTable::ALARM_TIME,
+            ReminderCalendarShareTable::STATE, ReminderCalendarShareTable::TITLE,
+            ReminderCalendarShareTable::CONTENT, ReminderCalendarShareTable::WANT_AGENT,
+            ReminderCalendarShareTable::BUTTONS, ReminderCalendarShareTable::SLOT_TYPE,
+            ReminderCalendarShareTable::IDENTIFIER, ReminderCalendarShareTable::TIME_INTERVAL,
+            ReminderCalendarShareTable::SNOOZE_TIMES, ReminderCalendarShareTable::RING_DURATION,
+            ReminderCalendarShareTable::SNOOZE_SLOT_TYPE, ReminderCalendarShareTable::SNOOZE_CONTENT,
+            ReminderCalendarShareTable::EXPIRED_CONTENT, ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT,
+            ReminderCalendarShareTable::CUSTOM_RING_URI
+        };
+    } else {
+        return std::vector<std::string> {
+            ReminderCalendarShareTable::ID, ReminderCalendarShareTable::EVENT_ID,
+            ReminderCalendarShareTable::END, ReminderCalendarShareTable::ALARM_TIME,
+            ReminderCalendarShareTable::STATE, ReminderCalendarShareTable::TITLE,
+            ReminderCalendarShareTable::CONTENT, ReminderCalendarShareTable::WANT_AGENT,
+            ReminderCalendarShareTable::BUTTONS, ReminderCalendarShareTable::SLOT_TYPE,
+            ReminderCalendarShareTable::IDENTIFIER
+        };
+    }
 }
 
 sptr<ReminderRequest> ReminderDataShareHelper::CreateReminder(
@@ -312,6 +342,7 @@ sptr<ReminderRequest> ReminderDataShareHelper::CreateReminder(
 {
     sptr<ReminderRequest> reminder = sptr<ReminderRequestCalendar>::MakeSptr();
     InitNormalInfo(reminder);
+    BuildReminderV1(result, reminder);
     uint64_t triggerTime = 0;
     GetRdbValue<uint64_t>(result, ReminderCalendarShareTable::ALARM_TIME, triggerTime);
     reminder->SetTriggerTimeInMilli(triggerTime);
@@ -371,6 +402,7 @@ std::map<std::string, sptr<ReminderRequest>> ReminderDataShareHelper::CreateRemi
             reminder->SetTriggerTimeInMilli(triggerTime);
         }
         InitBaseInfo(values, reminder);
+        BuildReminderV1(values, reminder);
         uint64_t endDateTime = 0;
         iter = values.find(ReminderCalendarShareTable::END);
         if (iter != values.end()) {
@@ -446,6 +478,79 @@ void ReminderDataShareHelper::InitBaseInfo(const DataShare::DataShareObserver::C
     }
 }
 
+void ReminderDataShareHelper::BuildReminderV1(const std::shared_ptr<DataShare::DataShareResultSet>& result,
+    sptr<ReminderRequest>& reminder)
+{
+    if (!isNewRdbVer_) {
+        return;
+    }
+    uint64_t timeInterval = 0;
+    GetRdbValue<uint64_t>(result, ReminderCalendarShareTable::TIME_INTERVAL, timeInterval);
+    reminder->SetTimeInterval(timeInterval);
+    uint8_t snoozeTimes = 0;
+    GetRdbValue<uint8_t>(result, ReminderCalendarShareTable::SNOOZE_TIMES, snoozeTimes);
+    reminder->SetSnoozeTimes(snoozeTimes);
+    uint64_t ringDuration = 0;
+    GetRdbValue<uint64_t>(result, ReminderCalendarShareTable::RING_DURATION, ringDuration);
+    reminder->SetRingDuration(ringDuration);
+    int32_t snoozeSlotType = 0;
+    GetRdbValue<int32_t>(result, ReminderCalendarShareTable::SNOOZE_SLOT_TYPE, snoozeSlotType);
+    reminder->SetSnoozeSlotType(NotificationConstant::SlotType(snoozeSlotType));
+    std::string snoozeContent;
+    GetRdbValue<std::string>(result, ReminderCalendarShareTable::SNOOZE_CONTENT, snoozeContent);
+    reminder->SetSnoozeContent(snoozeContent);
+    std::string expiredContent;
+    GetRdbValue<std::string>(result, ReminderCalendarShareTable::EXPIRED_CONTENT, expiredContent);
+    reminder->SetExpiredContent(expiredContent);
+    std::string maxScreenWantAgent;
+    GetRdbValue<std::string>(result, ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT, maxScreenWantAgent);
+    reminder->DeserializeWantAgent(maxScreenWantAgent, 1);
+    std::string customRingUri;
+    GetRdbValue<std::string>(result, ReminderCalendarShareTable::CUSTOM_RING_URI, customRingUri);
+    reminder->SetCustomRingUri(customRingUri);
+}
+
+void ReminderDataShareHelper::BuildReminderV1(const DataShare::DataShareObserver::ChangeInfo::VBucket& info,
+    sptr<ReminderRequest>& reminder)
+{
+    if (!isNewRdbVer_) {
+        return;
+    }
+    auto iter = info.find(ReminderCalendarShareTable::TIME_INTERVAL);
+    if (iter != info.end()) {
+        reminder->SetTimeInterval(static_cast<uint64_t>(std::get<double>(iter->second)));
+    }
+    iter = info.find(ReminderCalendarShareTable::SNOOZE_TIMES);
+    if (iter != info.end()) {
+        reminder->SetSnoozeTimes(static_cast<uint8_t>(std::get<double>(iter->second)));
+    }
+    iter = info.find(ReminderCalendarShareTable::RING_DURATION);
+    if (iter != info.end()) {
+        reminder->SetRingDuration(static_cast<uint64_t>(std::get<double>(iter->second)));
+    }
+    iter = info.find(ReminderCalendarShareTable::SNOOZE_SLOT_TYPE);
+    if (iter != info.end()) {
+        reminder->SetSnoozeSlotType(
+            NotificationConstant::SlotType(static_cast<int32_t>(std::get<double>(iter->second))));
+    }
+    iter = info.find(ReminderCalendarShareTable::SNOOZE_CONTENT);
+    if (iter != info.end()) {
+        reminder->SetSnoozeContent(std::get<std::string>(iter->second));
+    }
+    iter = info.find(ReminderCalendarShareTable::EXPIRED_CONTENT);
+    if (iter != info.end()) {
+        reminder->SetExpiredContent(std::get<std::string>(iter->second));
+    }
+    iter = info.find(ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT);
+    if (iter != info.end()) {
+        reminder->DeserializeWantAgent(std::get<std::string>(iter->second), 1);
+    }
+    iter = info.find(ReminderCalendarShareTable::CUSTOM_RING_URI);
+    if (iter != info.end()) {
+        reminder->SetCustomRingUri(std::get<std::string>(iter->second));
+    }
+}
+
 ReminderDataShareHelper::ReminderDataShareHelper()
 {
     queue_ = std::make_shared<ffrt::queue>("ReminderDataShareHelper");
diff --git a/services/reminder/test/unittest/reminder_data_manager_test.cpp b/services/reminder/test/unittest/reminder_data_manager_test.cpp
index ed53a3bdf5f8dda1bd4ad92aa222d1e1e108ca77..a1cd9d9bac049c0b6fa07fa3763bb9be4bc53819 100644
--- a/services/reminder/test/unittest/reminder_data_manager_test.cpp
+++ b/services/reminder/test/unittest/reminder_data_manager_test.cpp
@@ -1305,5 +1305,203 @@ HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_029, Level1)
     EXPECT_TRUE(manager != nullptr);
     sleep(1);
 }
+
+/**
+ * @tc.name: ReminderDataManagerTest_030
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_030, Level1)
+{
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = true;
+    auto result = ReminderDataShareHelper::GetInstance().GetColumns();
+    EXPECT_TRUE(result.size() == 19);
+
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
+    result = ReminderDataShareHelper::GetInstance().GetColumns();
+    EXPECT_TRUE(result.size() == 11);
+
+    sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
+    DataShare::DataShareObserver::ChangeInfo::VBucket info;
+
+    DataShare::DataShareObserver::ChangeInfo::Value ringDuration = static_cast<double>(10);
+    info[ReminderCalendarShareTable::RING_DURATION] = ringDuration;
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetRingDuration() == 1);
+
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = true;
+    info.clear();
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetRingDuration() == 1);
+
+    DataShare::DataShareObserver::ChangeInfo::Value timeInterval1 = static_cast<double>(UINT64_MAX);
+    info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval1;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetTimeInterval() == 0);
+
+    uint64_t testValue = UINT64_MAX / 500;
+    DataShare::DataShareObserver::ChangeInfo::Value timeInterval2 = static_cast<double>(testValue);
+    info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval2;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetTimeInterval() == 0);
+
+    testValue = UINT64_MAX / 1000 - 10;
+    DataShare::DataShareObserver::ChangeInfo::Value timeInterval3 = static_cast<double>(testValue);
+    info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval3;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetTimeInterval() < (UINT64_MAX / 1000));
+
+    DataShare::DataShareObserver::ChangeInfo::Value timeInterval4 = static_cast<double>(-100);
+    info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval4;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetTimeInterval() == 0);
+
+    testValue = 10;
+    DataShare::DataShareObserver::ChangeInfo::Value timeInterval5 = static_cast<double>(testValue);
+    info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval5;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetTimeInterval() == 300);
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
+}
+
+/**
+ * @tc.name: ReminderDataManagerTest_031
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_031, Level1)
+{
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = true;
+    sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
+    DataShare::DataShareObserver::ChangeInfo::VBucket info;
+    DataShare::DataShareObserver::ChangeInfo::Value snoozeTimes1 = static_cast<double>(UINT64_MAX);
+    info[ReminderCalendarShareTable::SNOOZE_TIMES] = snoozeTimes1;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetSnoozeTimes() == UINT8_MAX);
+
+    DataShare::DataShareObserver::ChangeInfo::Value snoozeTimes2 = static_cast<double>(-1);
+    info[ReminderCalendarShareTable::SNOOZE_TIMES] = snoozeTimes2;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetSnoozeTimes() == UINT8_MAX);
+
+    uint64_t testValue = 5;
+    DataShare::DataShareObserver::ChangeInfo::Value snoozeTimes3 = static_cast<double>(testValue);
+    info[ReminderCalendarShareTable::SNOOZE_TIMES] = snoozeTimes3;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetSnoozeTimes() == testValue);
+
+    DataShare::DataShareObserver::ChangeInfo::Value ringDuration1 = static_cast<double>(UINT64_MAX);
+    info[ReminderCalendarShareTable::RING_DURATION] = ringDuration1;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetRingDuration() == 0);
+
+    testValue = UINT64_MAX / 500;
+    DataShare::DataShareObserver::ChangeInfo::Value ringDuration2 = static_cast<double>(testValue);
+    info[ReminderCalendarShareTable::RING_DURATION] = ringDuration2;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetRingDuration() == 0);
+
+    testValue = UINT64_MAX / 1000 - 10;
+    DataShare::DataShareObserver::ChangeInfo::Value ringDuration3 = static_cast<double>(testValue);
+    info[ReminderCalendarShareTable::RING_DURATION] = ringDuration3;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetRingDuration() == ReminderRequest::MAX_RING_DURATION / 1000);
+
+    DataShare::DataShareObserver::ChangeInfo::Value ringDuration4 = static_cast<double>(-100);
+    info[ReminderCalendarShareTable::RING_DURATION] = ringDuration4;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetRingDuration() == 0);
+
+    testValue = 10;
+    DataShare::DataShareObserver::ChangeInfo::Value ringDuration5 = static_cast<double>(testValue);
+    info[ReminderCalendarShareTable::RING_DURATION] = ringDuration5;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetRingDuration() == testValue);
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
+}
+
+/**
+ * @tc.name: ReminderDataManagerTest_032
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_032, Level1)
+{
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = true;
+    sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
+    DataShare::DataShareObserver::ChangeInfo::VBucket info;
+    DataShare::DataShareObserver::ChangeInfo::Value type = static_cast<double>(1);
+    info[ReminderCalendarShareTable::SNOOZE_SLOT_TYPE] = type;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    int32_t result = static_cast<int32_t>(timer->GetSnoozeSlotType());
+    EXPECT_TRUE(result == 1);
+
+    std::string testValue;
+    DataShare::DataShareObserver::ChangeInfo::Value snoozeContent1 = testValue;
+    info[ReminderCalendarShareTable::SNOOZE_CONTENT] = snoozeContent1;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetSnoozeContent() == testValue);
+
+    DataShare::DataShareObserver::ChangeInfo::Value expiredContent1 = testValue;
+    info[ReminderCalendarShareTable::EXPIRED_CONTENT] = expiredContent1;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetExpiredContent() == testValue);
+
+    DataShare::DataShareObserver::ChangeInfo::Value uri1 = testValue;
+    info[ReminderCalendarShareTable::CUSTOM_RING_URI] = uri1;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetCustomRingUri() == testValue);
+
+    testValue = "testValue";
+    DataShare::DataShareObserver::ChangeInfo::Value snoozeContent2 = testValue;
+    info[ReminderCalendarShareTable::SNOOZE_CONTENT] = snoozeContent2;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetSnoozeContent() == testValue);
+
+    DataShare::DataShareObserver::ChangeInfo::Value expiredContent2 = testValue;
+    info[ReminderCalendarShareTable::EXPIRED_CONTENT] = expiredContent2;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetExpiredContent() == testValue);
+
+    DataShare::DataShareObserver::ChangeInfo::Value uri2 = testValue;
+    info[ReminderCalendarShareTable::CUSTOM_RING_URI] = uri2;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->GetCustomRingUri() == testValue);
+
+    testValue = "";
+    DataShare::DataShareObserver::ChangeInfo::Value wantAgent1 = testValue;
+    info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent1;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == testValue);
+
+    testValue = "iodahfoibnaoje";
+    DataShare::DataShareObserver::ChangeInfo::Value wantAgent2 = testValue;
+    info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent2;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == "");
+
+    testValue = R"(1)";
+    DataShare::DataShareObserver::ChangeInfo::Value wantAgent3 = testValue;
+    info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent3;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == "");
+
+    testValue = R"({})";
+    DataShare::DataShareObserver::ChangeInfo::Value wantAgent4 = testValue;
+    info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent4;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == "");
+
+    testValue = R"({"pkgName": "com.aaa.aaa", "abilityName": "Entry"})";
+    DataShare::DataShareObserver::ChangeInfo::Value wantAgent5 = testValue;
+    info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent5;
+    ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
+    EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == "Entry");
+    ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
+}
 }  // namespace Notification
 }  // namespace OHOS