diff --git a/frameworks/js/napi/include/reminder/publish.h b/frameworks/js/napi/include/reminder/publish.h
index a875364cd1655e45b8e7c3223c90b42587f9e932..5c22e59e77d2fc2250e0fbeeecc26145e2d04ac9 100644
--- a/frameworks/js/napi/include/reminder/publish.h
+++ b/frameworks/js/napi/include/reminder/publish.h
@@ -64,6 +64,15 @@ napi_value GetAllValidReminders(napi_env env, napi_callback_info info);
  */
 napi_value PublishReminder(napi_env env, napi_callback_info info);
 
+/**
+ * @brief Updates a reminder.
+ *
+ * @param env Indicates the context.
+ * @param info Indicates the opaque datatype about the context.
+ * @return opaque pointer that is used to represent a JavaScript value
+ */
+napi_value UpdateReminder(napi_env env, napi_callback_info info);
+
 /**
  * @brief Adds a slot type.
  *
diff --git a/frameworks/js/napi/src/reminder/native_module_manager.cpp b/frameworks/js/napi/src/reminder/native_module_manager.cpp
index e0c998fc7e192c08179d9733256328b1a2cc3d64..bc6b2cc19386c68a5797edb80b1342e88e0b3cc7 100644
--- a/frameworks/js/napi/src/reminder/native_module_manager.cpp
+++ b/frameworks/js/napi/src/reminder/native_module_manager.cpp
@@ -37,6 +37,7 @@ napi_value ReminderAgentManagerInit(napi_env env, napi_value exports)
         DECLARE_NAPI_FUNCTION("addExcludeDate", AddExcludeDate),
         DECLARE_NAPI_FUNCTION("deleteExcludeDates", DelExcludeDates),
         DECLARE_NAPI_FUNCTION("getExcludeDates", GetExcludeDates),
+        DECLARE_NAPI_FUNCTION("updateReminder", UpdateReminder),
     };
     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
     return exports;
diff --git a/frameworks/js/napi/src/reminder/publish.cpp b/frameworks/js/napi/src/reminder/publish.cpp
index 124ec328f990e7474ad6f41f87273b00ec19fa6e..45a3fab917e0c27513f832f65b2a62a875888a75 100644
--- a/frameworks/js/napi/src/reminder/publish.cpp
+++ b/frameworks/js/napi/src/reminder/publish.cpp
@@ -33,6 +33,7 @@ static const int32_t GET_VALID_PARAM_LEN = 1;
 static const int32_t ADD_SLOT_PARAM_LEN = 2;
 static constexpr int32_t ADD_EXCLUDE_DATE_PARAM_LEN = 2;
 static constexpr int32_t DEL_EXCLUDE_DATE_PARAM_LEN = 1;
+static constexpr int32_t UPDATE_REMINDER_PARAM_LEN = 2;
 
 struct AsyncCallbackInfo {
     explicit AsyncCallbackInfo(napi_env napiEnv) : env(napiEnv) {}
@@ -1406,5 +1407,95 @@ napi_value GetExcludeDates(napi_env env, napi_callback_info info)
 
     return isCallback ? NotificationNapi::Common::NapiGetNull(env) : promise;
 }
+
+napi_value ParseUpdateReminderParameter(const napi_env &env, const napi_callback_info &info, Parameters &params)
+{
+    ANSR_LOGD("ParseUpdateReminderParameter");
+    size_t argc = UPDATE_REMINDER_PARAM_LEN;
+    napi_value argv[UPDATE_REMINDER_PARAM_LEN] = {nullptr};
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
+    if (argc < UPDATE_REMINDER_PARAM_LEN) {
+        ANSR_LOGE("Wrong number of arguments");
+        ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
+        return nullptr;
+    }
+
+    // argv[0]: reminder id
+    int32_t reminderId = -1;
+    if (!ReminderCommon::GetInt32(env, argv[0], nullptr, reminderId, true)) {
+        ANSR_LOGE("Parse reminder id failed.");
+        ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
+        return nullptr;
+    }
+    if (reminderId < 0) {
+        ANSR_LOGE("Param reminder id is illegal.");
+        ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
+        return nullptr;
+    }
+    if (ReminderCommon::GetReminderRequest(env, argv[1], params.reminder) == nullptr) {
+        ANSR_LOGE("[reminderAgent]UpdateReminder returns nullptr");
+        ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
+        return nullptr;
+    }
+    params.reminderId = reminderId;
+    return NotificationNapi::Common::NapiGetNull(env);
+}
+
+napi_value UpdateReminder(napi_env env, napi_callback_info info)
+{
+    ANSR_LOGD("Call UpdateReminder");
+    AsyncCallbackInfo *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfo(env);
+    if (!asynccallbackinfo) {
+        ANSR_LOGE("Low memory.");
+        return NotificationNapi::Common::NapiGetNull(env);
+    }
+    std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
+
+    // param
+    Parameters params;
+    if (ParseUpdateReminderParameter(env, info, params) == nullptr) {
+        return DealErrorReturn(env, asynccallbackinfo->callback, NotificationNapi::Common::NapiGetNull(env), true);
+    }
+
+    // promise
+    napi_value promise = nullptr;
+    SetAsynccallbackinfo(env, *asynccallbackinfo, promise);
+    asynccallbackinfo->reminderId = params.reminderId;
+    asynccallbackinfo->reminder = params.reminder;
+    asynccallbackinfo->isThrow = true;
+
+    // resource name
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "updateReminder", NAPI_AUTO_LENGTH, &resourceName);
+
+    bool isCallback = asynccallbackinfo->info.isCallback;
+    // create and queue async work
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANSR_LOGI("UpdateReminder napi_create_async_work start");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfo *>(data);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = ReminderHelper::UpdateReminder(asynccallbackinfo->reminderId,
+                    *(asynccallbackinfo->reminder));
+            }
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANSR_LOGI("UpdateReminder napi_create_async_work complete start");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfo *>(data);
+            std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
+
+            ReminderCommon::ReturnCallbackPromise(
+                env, asynccallbackinfo->info, NotificationNapi::Common::NapiGetNull(env), asynccallbackinfo->isThrow);
+            ANSR_LOGI("UpdateReminder napi_create_async_work complete end");
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    callbackPtr.release();
+
+    return isCallback ? NotificationNapi::Common::NapiGetNull(env) : promise;
+}
 }
 }
diff --git a/frameworks/reminder/IReminderAgentService.idl b/frameworks/reminder/IReminderAgentService.idl
index e1c9c304f1e5efdbd672ac011bc5decb67f3920b..3dcf14bc43b71c29840ece3dcf06c013a849ce90 100644
--- a/frameworks/reminder/IReminderAgentService.idl
+++ b/frameworks/reminder/IReminderAgentService.idl
@@ -17,6 +17,7 @@ sequenceable OHOS.Notification.ReminderRequest;
 sequenceable OHOS.Notification.ReminderRequestAdaptation;
 interface OHOS.Notification.IReminderAgentService {
     void PublishReminder([in] ReminderRequest reminder, [out] int reminderId);
+    void UpdateReminder([in] int reminderId, [in] ReminderRequest reminder);
     void CancelReminder([in] int reminderId);
     void CancelAllReminders();
     void GetValidReminders([out] ReminderRequestAdaptation[] reminders);
diff --git a/frameworks/reminder/src/reminder_helper.cpp b/frameworks/reminder/src/reminder_helper.cpp
index 573c51e6ec1621c534348cab8103908f12fb3144..7db46691694f02076996aae9215113335486b511 100644
--- a/frameworks/reminder/src/reminder_helper.cpp
+++ b/frameworks/reminder/src/reminder_helper.cpp
@@ -27,6 +27,12 @@ ErrCode ReminderHelper::PublishReminder(const ReminderRequest& reminder, int32_t
     return DelayedSingleton<ReminderRequestClient>::GetInstance()->PublishReminder(reminder, reminderId);
 }
 
+ErrCode ReminderHelper::UpdateReminder(const int32_t reminderId, const ReminderRequest& reminder)
+{
+    ANSR_LOGI("UpdateReminder start");
+    return DelayedSingleton<ReminderRequestClient>::GetInstance()->UpdateReminder(reminderId, reminder);
+}
+
 ErrCode ReminderHelper::CancelReminder(const int32_t reminderId)
 {
     ANSR_LOGI("CancelReminder start");
diff --git a/frameworks/reminder/src/reminder_request_client.cpp b/frameworks/reminder/src/reminder_request_client.cpp
index e262a1bd62f945392ce10732e8441f790be1c8d8..a112b2b882fc1d260db07bc90b7cea553f591ca5 100644
--- a/frameworks/reminder/src/reminder_request_client.cpp
+++ b/frameworks/reminder/src/reminder_request_client.cpp
@@ -81,6 +81,17 @@ ErrCode ReminderRequestClient::PublishReminder(const ReminderRequest& reminder,
     return proxy->PublishReminder(reminder, reminderId);
 }
 
+ErrCode ReminderRequestClient::UpdateReminder(const int32_t reminderId, const ReminderRequest& reminder)
+{
+    AddSlotByType(reminder.GetSlotType());
+    sptr<IReminderAgentService> proxy = GetReminderServiceProxy();
+    if (!proxy) {
+        ANS_LOGE("GetReminderServiceProxy fail.");
+        return ERR_ANS_SERVICE_NOT_CONNECTED;
+    }
+    return proxy->UpdateReminder(reminderId, reminder);
+}
+
 ErrCode ReminderRequestClient::CancelReminder(const int32_t reminderId)
 {
     sptr<IReminderAgentService> proxy = GetReminderServiceProxy();
diff --git a/frameworks/reminder/test/unittest/reminder_agent_proxy_test.cpp b/frameworks/reminder/test/unittest/reminder_agent_proxy_test.cpp
index aead7463a279ed0bc1754e5c5ff2124105f6d0c2..b147cd46ca1918a93ded9e53a628dbca13b74696 100644
--- a/frameworks/reminder/test/unittest/reminder_agent_proxy_test.cpp
+++ b/frameworks/reminder/test/unittest/reminder_agent_proxy_test.cpp
@@ -206,5 +206,49 @@ HWTEST_F(ReminderAgentServiceProxyTest, GetExcludeDates_0100, Function | MediumT
     EXPECT_EQ(ERR_OK, res);
 }
 
+/*
+ * @tc.name: UpdateReminder_0100
+ * @tc.desc: test ReminderAgentServiceProxy's UpdateReminder function
+ * @tc.type: FUNC
+ * @tc.require: #I5XO2O
+ */
+HWTEST_F(ReminderAgentServiceProxyTest, UpdateReminder_0100, Function | MediumTest | Level1)
+{
+    GTEST_LOG_(INFO)
+        << "ReminderAgentServiceProxyTest, UpdateReminder_0100, TestSize.Level1";
+    MockWriteInterfaceToken(false);
+    sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
+    ASSERT_NE(nullptr, iremoteObject);
+    std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
+    ASSERT_NE(nullptr, proxy);
+
+    int32_t reminderId = 0;
+    ReminderRequest reminderRequest;
+    ErrCode res = proxy->UpdateReminder(reminderId, reminderRequest);
+    EXPECT_NE(ERR_OK, res);
+}
+
+/*
+ * @tc.name: UpdateReminder_0200
+ * @tc.desc: test ReminderAgentServiceProxy's UpdateReminder function
+ * @tc.type: FUNC
+ * @tc.require: #I5XO2O
+ */
+HWTEST_F(ReminderAgentServiceProxyTest, UpdateReminder_0200, Function | MediumTest | Level1)
+{
+    GTEST_LOG_(INFO)
+        << "ReminderAgentServiceProxyTest, UpdateReminder_0200, TestSize.Level1";
+    MockWriteInterfaceToken(true);
+    sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
+    ASSERT_NE(nullptr, iremoteObject);
+    std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
+    ASSERT_NE(nullptr, proxy);
+
+    int32_t reminderId = 0;
+    ReminderRequest reminderRequest;
+    reminderRequest.SetReminderType(ReminderRequest::ReminderType::TIMER);
+    ErrCode res = proxy->UpdateReminder(reminderId, reminderRequest);
+    EXPECT_EQ(ERR_OK, res);
+}
 }
 }
diff --git a/frameworks/reminder/test/unittest/reminder_helper_test.cpp b/frameworks/reminder/test/unittest/reminder_helper_test.cpp
index 896bb02db218b7121d042c83d77260582721c580..3889cdaa9143b4109499320eff0d5b917c3fe851 100644
--- a/frameworks/reminder/test/unittest/reminder_helper_test.cpp
+++ b/frameworks/reminder/test/unittest/reminder_helper_test.cpp
@@ -180,5 +180,20 @@ HWTEST_F(ReminderHelperTest, GetExcludeDates_00001, Function | SmallTest | Level
     ErrCode ret = reminderHelper.GetExcludeDates(reminderId, dates);
     EXPECT_NE(ret, (int)ERR_ANS_INVALID_BUNDLE);
 }
+
+/**
+ * @tc.name: UpdateReminder_00001
+ * @tc.desc: Test UpdateReminder parameters.
+ * @tc.type: FUNC
+ * @tc.require: issue#I9F24R
+ */
+HWTEST_F(ReminderHelperTest, UpdateReminder_00001, Function | SmallTest | Level1)
+{
+    ReminderRequest reminder;
+    ReminderHelper reminderHelper;
+    int32_t reminderId = 1;
+    ErrCode ret = reminderHelper.UpdateReminder(reminderId, reminder);
+    EXPECT_NE(ret, (int)ERR_OK);
+}
 }
 }
diff --git a/interfaces/inner_api/reminder_helper.h b/interfaces/inner_api/reminder_helper.h
index 5d9952c2f23b83c990af0067c1d34d6635efbba3..45cfd24f70acda1cd35573e63b407aad5dd33959 100644
--- a/interfaces/inner_api/reminder_helper.h
+++ b/interfaces/inner_api/reminder_helper.h
@@ -51,6 +51,15 @@ public:
      */
     static ErrCode PublishReminder(const ReminderRequest &reminder, int32_t& reminderId);
 
+    /**
+     * @brief Updates a scheduled reminder.
+     *
+     * @param reminderId Indicates reminder Id.
+     * @param reminder Indicates a reminder.
+     * @return Returns publish result.
+     */
+    static ErrCode UpdateReminder(const int32_t reminderId, const ReminderRequest& reminder);
+
     /**
      * Cancels a specified reminder.
      *
diff --git a/interfaces/inner_api/reminder_request_client.h b/interfaces/inner_api/reminder_request_client.h
index 1dc3a9646060695c95ef6d6781fd8214d5ee1311..44b5c46e9562ef386b33f9c342375f868aa8e6d9 100644
--- a/interfaces/inner_api/reminder_request_client.h
+++ b/interfaces/inner_api/reminder_request_client.h
@@ -37,6 +37,15 @@ public:
      */
     ErrCode PublishReminder(const ReminderRequest& reminder, int32_t& reminderId);
 
+    /**
+     * @brief Updates a scheduled reminder.
+     *
+     * @param reminderId Indicates reminder Id.
+     * @param reminder Indicates a reminder.
+     * @return Returns publish result.
+     */
+    ErrCode UpdateReminder(const int32_t reminderId, const ReminderRequest& reminder);
+
     /**
      * @brief Cancels a specified reminder.
      *
diff --git a/services/reminder/include/reminder_agent_service.h b/services/reminder/include/reminder_agent_service.h
index 19c33bbe37e2dd26c3994f99411eaf423352a6bb..74d715199f4a454ad30334c5ac885b7736f66478 100644
--- a/services/reminder/include/reminder_agent_service.h
+++ b/services/reminder/include/reminder_agent_service.h
@@ -44,6 +44,15 @@ public:
      */
     ErrCode PublishReminder(const ReminderRequest& reminder, int32_t& reminderId) override;
 
+    /**
+     * @brief Updates a reminder request.
+     *
+     * @param reminderId Identifies the reminder id that needs to be updated.
+     * @param reminder Identifies the reminder request that needs to be updated.
+     * @return Returns ERR_OK on success, others on failure.
+     */
+    ErrCode UpdateReminder(const int32_t reminderId, const ReminderRequest& reminder) override;
+
     /**
      * @brief Cancel a reminder request.
      *
diff --git a/services/reminder/include/reminder_data_manager.h b/services/reminder/include/reminder_data_manager.h
index 3d22df0c9b0c5c7f8b15404f4a2f32b722da8bf3..aa63fab8bcd9c8c2ac6bf192d0e244437ce857eb 100644
--- a/services/reminder/include/reminder_data_manager.h
+++ b/services/reminder/include/reminder_data_manager.h
@@ -184,6 +184,15 @@ public:
     ErrCode PublishReminder(const sptr<ReminderRequest> &reminder,
         const int32_t callingUid);
 
+    /**
+     * Updates a scheduled reminder.
+     *
+     * @param reminder Indicates the reminder.
+     * @param callingUid Indicates uid the reminder belongs to.
+     * @return ERR_OK if success, else not.
+     */
+    ErrCode UpdateReminder(const sptr<ReminderRequest> &reminder, const int32_t callingUid);
+
     /**
      * @brief Refresh all reminders when date/time or timeZone of device changed by user.
      *
@@ -612,6 +621,7 @@ private:
      * @param reminder Indicates a reminder.
      */
     void UpdateAndSaveReminderLocked(const sptr<ReminderRequest> &reminder);
+    void UpdateAndSaveReminderLocked(const sptr<ReminderRequest>& reminder, const bool isInMemory);
 
     static bool cmp(sptr<ReminderRequest> &reminderRequest, sptr<ReminderRequest> &other);
 
diff --git a/services/reminder/include/reminder_store.h b/services/reminder/include/reminder_store.h
index 9b9a312a43d7fdbe919de743703e3c87410ca1af..ed9ba8b84b335ff0dae50ca9d5e39a1e12d3c999 100644
--- a/services/reminder/include/reminder_store.h
+++ b/services/reminder/include/reminder_store.h
@@ -41,6 +41,7 @@ public:
     int32_t UpdateOrInsert(const sptr<ReminderRequest>& reminder);
     int32_t GetMaxId();
     int32_t QueryActiveReminderCount();
+    bool IsReminderExist(const int32_t reminderId, const int32_t uid);
     std::vector<sptr<ReminderRequest>> GetHalfHourReminders();
     std::vector<sptr<ReminderRequest>> GetAllValidReminders();
 
diff --git a/services/reminder/src/reminder_agent_service.cpp b/services/reminder/src/reminder_agent_service.cpp
index 99ff3881feb167fe7f016482e9bf8d041e42e853..c172dfc7d59c1295a5b51ab36ddd038937a93d66 100644
--- a/services/reminder/src/reminder_agent_service.cpp
+++ b/services/reminder/src/reminder_agent_service.cpp
@@ -105,6 +105,35 @@ ErrCode ReminderAgentService::PublishReminder(const ReminderRequest& reminder, i
     return ret;
 }
 
+ErrCode ReminderAgentService::UpdateReminder(const int32_t reminderId, const ReminderRequest& reminder)
+{
+    HITRACE_METER_NAME(HITRACE_TAG_OHOS, __PRETTY_FUNCTION__);
+    ANSR_LOGD("call.");
+    sptr<ReminderRequest> tarReminder = CreateReminderRequest(reminder);
+    if (nullptr == tarReminder) {
+        ANSR_LOGE("Failed to create ReminderRequest.");
+        return ERR_REMINDER_INVALID_PARAM;
+    }
+    if (!CheckReminderPermission()) {
+        ANSR_LOGE("Failed to check permission: ohos.permission.PUBLISH_AGENT_REMINDER.");
+        return ERR_REMINDER_PERMISSION_DENIED;
+    }
+    int32_t callingUid = IPCSkeleton::GetCallingUid();
+    std::string bundleName = GetClientBundleName(callingUid);
+    ErrCode ret = InitReminderRequest(tarReminder, bundleName, callingUid);
+    if (ret != ERR_OK) {
+        return ret;
+    }
+    auto rdm = ReminderDataManager::GetInstance();
+    if (nullptr == rdm) {
+        return ERR_NO_INIT;
+    }
+    tarReminder->SetReminderId(reminderId);
+    ret = rdm->UpdateReminder(tarReminder, callingUid);
+    TryPostDelayUnloadTask(UNLOAD_TASK_DELAY_TIME);
+    return ret;
+}
+
 ErrCode ReminderAgentService::CancelReminder(const int32_t reminderId)
 {
     HITRACE_METER_NAME(HITRACE_TAG_OHOS, __PRETTY_FUNCTION__);
diff --git a/services/reminder/src/reminder_data_manager_inner.cpp b/services/reminder/src/reminder_data_manager_inner.cpp
index 1e0eb507aeb55341792b6b498314193989b07d21..1ea1a2f7c1f2ab00f933388d202aa5d7ef3cc044 100644
--- a/services/reminder/src/reminder_data_manager_inner.cpp
+++ b/services/reminder/src/reminder_data_manager_inner.cpp
@@ -259,5 +259,59 @@ void ReminderDataManager::AsyncStartExtensionAbility(const sptr<ReminderRequest>
         serviceQueue_->submit(callback, taskAttr);
     }
 }
+
+ErrCode ReminderDataManager::UpdateReminder(const sptr<ReminderRequest>& reminder, const int32_t callingUid)
+{
+    HITRACE_METER_NAME(HITRACE_TAG_OHOS, __PRETTY_FUNCTION__);
+    sptr<ReminderRequest> reminderOld = FindReminderRequestLocked(reminder->GetReminderId(), false);
+    bool existInMemory = true;
+    if (nullptr != reminderOld) {
+        if (reminderOld->IsShowing()) {
+            ANSR_LOGW("Reminder already showing, update reminder failed.");
+            return ERR_REMINDER_NOT_EXIST;
+        }
+    } else {
+        existInMemory = false;
+        std::lock_guard<std::mutex> lock(ReminderDataManager::MUTEX);
+        if (!store_->IsReminderExist(reminder->GetReminderId(), reminder->GetCreatorUid())) {
+            ANSR_LOGW("Reminder not find, update reminder failed.");
+            return ERR_REMINDER_NOT_EXIST;
+        }
+    }
+    uint32_t callerTokenId = IPCSkeleton::GetCallingTokenID();
+    if (callerTokenId == 0) {
+        ANSR_LOGE("pushlish failed, callerTokenId is 0");
+        return ERR_REMINDER_CALLER_TOKEN_INVALID;
+    }
+    if (!IsActionButtonDataShareValid(reminder, callerTokenId)) {
+        return ERR_REMINDER_DATA_SHARE_PERMISSION_DENIED;
+    }
+
+    UpdateAndSaveReminderLocked(reminder, existInMemory);
+    queue_->submit([this, reminder]() {
+        StartRecentReminder();
+    });
+    return ERR_OK;
+}
+
+void ReminderDataManager::UpdateAndSaveReminderLocked(const sptr<ReminderRequest>& reminder, const bool isInMemory)
+{
+    std::lock_guard<std::mutex> lock(ReminderDataManager::MUTEX);
+    if (reminder->GetTriggerTimeInMilli() == ReminderRequest::INVALID_LONG_LONG_VALUE) {
+        ANSR_LOGW("now publish reminder is expired. reminder is =%{public}s", reminder->Dump().c_str());
+        reminder->SetExpired(true);
+    }
+    if (isInMemory) {
+        for (auto it = reminderVector_.begin(); it != reminderVector_.end(); ++it) {
+            if (reminder->GetReminderId() == (*it)->GetReminderId() && !(*it)->IsShare()) {
+                *it = reminder;
+                break;
+            }
+        }
+    } else {
+        reminderVector_.push_back(reminder);
+    }
+    store_->UpdateOrInsert(reminder);
+}
 }
 }
diff --git a/services/reminder/src/reminder_store.cpp b/services/reminder/src/reminder_store.cpp
index ca32a429f593fc6bab15b118018a5852515c45bb..1f3b71e25cefcc8e94feb48c4c6c2e1a6ac3b960 100644
--- a/services/reminder/src/reminder_store.cpp
+++ b/services/reminder/src/reminder_store.cpp
@@ -743,6 +743,21 @@ bool ReminderStore::IsReminderExist(const sptr<ReminderRequest>& reminder)
     return resultNum != 0;
 }
 
+bool ReminderStore::IsReminderExist(const int32_t reminderId, const int32_t uid)
+{
+    NativeRdb::AbsRdbPredicates absRdbPredicates(ReminderBaseTable::TABLE_NAME);
+    absRdbPredicates.EqualTo(ReminderBaseTable::REMINDER_ID, std::to_string(reminderId));
+    absRdbPredicates.EqualTo(ReminderBaseTable::CREATOR_UID, std::to_string(uid));
+    auto queryResultSet = rdbStore_->Query(absRdbPredicates, std::vector<std::string>());
+    if (queryResultSet == nullptr) {
+        ANSR_LOGE("QueryResultSet is null.");
+        return false;
+    }
+    int32_t resultNum;
+    queryResultSet->GetRowCount(resultNum);
+    return resultNum != 0;
+}
+
 std::vector<sptr<ReminderRequest>> ReminderStore::GetReminders(const std::string& queryCondition)
 {
     std::vector<sptr<ReminderRequest>> reminders;
diff --git a/services/reminder/test/unittest/reminder_agent_service_test.cpp b/services/reminder/test/unittest/reminder_agent_service_test.cpp
index f7b0343b3a2c86ecd126b6b8be88b7b56045ff09..c687328487bd8d24d2bcdc2775f933e7402565fd 100644
--- a/services/reminder/test/unittest/reminder_agent_service_test.cpp
+++ b/services/reminder/test/unittest/reminder_agent_service_test.cpp
@@ -437,4 +437,56 @@ HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_016, Function | Smal
     MockReminderBundleManagerHelper::MockGetBundleNameByUid("");
     EXPECT_EQ(reminderAgentService_->GetClientBundleName(1), "");
 }
+
+/**
+ * @tc.name: ReminderAgentServiceTest_017
+ * @tc.desc: Test UpdateReminder function
+ * @tc.type: FUNC
+ * @tc.require: issueI5S4VP
+ */
+HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_017, Function | SmallTest | Level1)
+{
+    // test CreateReminderRequest
+    int32_t reminderId = 0;
+    ReminderRequest reminder;
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(reminderId, reminder), ERR_REMINDER_INVALID_PARAM);
+    
+    // test CheckReminderPermission
+    MockAccesstokenKit::MockIsVerifyPermisson(false);
+    ReminderRequestAlarm alarm;
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), ERR_REMINDER_PERMISSION_DENIED);
+    MockAccesstokenKit::MockIsVerifyPermisson(true);
+
+    // test AllowUseReminder
+    MockNotificationHelper::MockIsAllowUseReminder(false);
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), ERR_REMINDER_NUMBER_OVERLOAD);
+    MockNotificationHelper::MockIsAllowUseReminder(true);
+
+    // test InitReminderRequest
+    auto wantInfo = alarm.GetMaxScreenWantAgentInfo();
+    alarm.SetMaxScreenWantAgentInfo(nullptr);
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), ERR_REMINDER_INVALID_PARAM);
+    alarm.SetMaxScreenWantAgentInfo(wantInfo);
+
+    // test IsSystemApp and IsAllowedNotify
+    alarm.SetSystemApp(false);
+    MockNotificationHelper::MockIsAllowedNotify(false, 1);
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), ERR_REMINDER_NOTIFICATION_NOT_ENABLE);
+    MockNotificationHelper::MockIsAllowedNotify(false, 0);
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), ERR_REMINDER_NOTIFICATION_NOT_ENABLE);
+    MockNotificationHelper::MockIsAllowedNotify(true, 0);
+
+    // test ReminderDataManager::GetInstance()
+    ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), ERR_NO_INIT);
+    alarm.SetSystemApp(true);
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), ERR_NO_INIT);
+    ReminderDataManager::InitInstance();
+
+    // test ReminderDataManager::PublishReminder
+    MockReminderDataManager::MockPublishReminder(1);
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), 1);
+    MockReminderDataManager::MockPublishReminder(0);
+    EXPECT_EQ(reminderAgentService_->UpdateReminder(alarm, reminderId), 0);
+}
 }  // namespace OHOS::Notification