diff --git a/services/context/inc/context_callback.h b/services/context/inc/context_callback.h
index f96ce4945152fc211e21ae05d9f3a90d6f8e5be5..ddca9101e8d6a07ae5778c0841ba40e2da8c66f4 100644
--- a/services/context/inc/context_callback.h
+++ b/services/context/inc/context_callback.h
@@ -75,6 +75,7 @@ public:
     virtual ~ContextCallback() = default;
     virtual void OnResult(int32_t resultCode, const Attributes &finalResult) = 0;
     virtual void OnAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector<uint8_t> &acquireMsg) = 0;
+    virtual void OnClear();
     virtual void SetTraceCallerName(const std::string &callerName) = 0;
     virtual void SetTraceRequestContextId(uint64_t requestContextId) = 0;
     virtual void SetTraceAuthContextId(uint64_t authContextId) = 0;
@@ -95,6 +96,7 @@ public:
     virtual void SetTraceConnectionName(const std::string &connectionName) = 0;
     virtual void SetTraceAuthFinishReason(const std::string &authFinishReason) = 0;
     virtual void SetTraceIsBackgroundApplication(bool isBackgroundApplication) = 0;
+    virtual void SetDestroyContextFlag(bool destroyContextFlag) = 0;
     virtual int32_t ParseAuthTipInfo(int32_t tip, const std::vector<uint8_t> &extraInfo,
         int32_t &authResult, int32_t &freezingTime) = 0;
     virtual void ProcessAuthResult(int32_t tip, const std::vector<uint8_t> &extraInfo) = 0;
@@ -104,4 +106,4 @@ public:
 } // namespace UserAuth
 } // namespace UserIam
 } // namespace OHOS
-#endif // IAM_CONTEXT_CALLBACK_H
\ No newline at end of file
+#endif // IAM_CONTEXT_CALLBACK_H
diff --git a/services/context/inc/widget_client.h b/services/context/inc/widget_client.h
index f11aaf7330bbd2ffe85d941c1d4cde0b33b37a00..625f1458a5b6b7af71679d77c8771c324d2685d0 100644
--- a/services/context/inc/widget_client.h
+++ b/services/context/inc/widget_client.h
@@ -66,6 +66,7 @@ private:
     bool GetAuthTypeList(const WidgetNotice &notice, std::vector<AuthType> &authTypeList);
     bool IsValidNoticeType(const WidgetNotice &notice);
     void ProcessNotice(const WidgetNotice &notice, std::vector<AuthType> &authTypeList);
+    void ProcWidgetRelease(std::vector<AuthType> &authTypeList);
 
 private:
     std::shared_ptr<WidgetScheduleNode> schedule_ {nullptr};
@@ -78,8 +79,11 @@ private:
     uint32_t authTokenId_ {0};
     std::vector<uint8_t> challenge_ {};
     std::string callingBundleName_ {""};
+
+    std::recursive_mutex mutex_;
+    std::vector<AuthType> curAuthTypeList_ {};
 };
 } // namespace UserAuth
 } // namespace UserIam
 } // namespace OHOS
-#endif // IAM_WIDGET_CLIENT_H
\ No newline at end of file
+#endif // IAM_WIDGET_CLIENT_H
diff --git a/services/context/inc/widget_context.h b/services/context/inc/widget_context.h
index 0f42bf3d5f5e999440e6cb7a5bafbf2ad659a23d..61bbc471a31b93cd7cf4db53f08a32a7047a8f06 100644
--- a/services/context/inc/widget_context.h
+++ b/services/context/inc/widget_context.h
@@ -82,7 +82,7 @@ public:
 
     void AuthResult(int32_t resultCode, int32_t authType, const Attributes &finalResult);
     void AuthTipInfo(int32_t tipInfo, int32_t authType, const Attributes &extraInfo);
-    void SendAuthResult() override;
+    void ClearSchedule() override;
     void SendAuthTipInfo(int32_t authType, int32_t tipInfo) override;
 
 protected:
@@ -123,12 +123,9 @@ private:
     void ProcAuthResult(int32_t resultCode, AuthType authType, int32_t freezingTime,
         const Attributes &finalResult);
     void ProcAuthTipInfo(int32_t tip, AuthType authType, const std::vector<uint8_t> &extraInfo);
-    void StartOnResultTimer(int32_t resultCode, AuthType authType, int32_t freezingTime);
-    void StopOnResultTimer();
-    void OnResultTimerTimeOut(int32_t resultCode, AuthType authType, int32_t freezingTime);
-    void StartOnTipTimer(AuthType authType, int32_t freezingTime);
-    void StopOnTipTimer();
-    void OnTipTimerTimeOut(AuthType authType, int32_t freezingTime);
+    void StartClearTimer();
+    void StopClearTimer();
+    void OnClearTimeOut();
 
 private:
     struct TaskInfo {
@@ -166,9 +163,7 @@ private:
     WidgetAuthResultInfo authResultInfo_ {};
     int32_t faceReload_ {0};
     uint32_t widgetAlreadyLoad_ {0};
-    uint32_t onResultTimerId_ {0};
-    uint32_t onTipTimerId_ {0};
-    ResultInfo resultInfo_{0};
+    uint32_t clearTimerId_ {0};
     nlohmann::json jsonBuf_ = {};
 };
 } // namespace UserAuth
diff --git a/services/context/src/context_callback_impl.cpp b/services/context/src/context_callback_impl.cpp
index e43c7eab3113e733e2e6b10d61aefa910c69c979..f0cb43d6e3147a4994d84db709e855a2b95cfe00 100644
--- a/services/context/src/context_callback_impl.cpp
+++ b/services/context/src/context_callback_impl.cpp
@@ -136,7 +136,7 @@ void ContextCallbackImpl::OnResult(int32_t resultCode, const Attributes &finalRe
     HandleAuthSuccessResult(resultCode, finalResult);
 
     ContextCallbackNotifyListener::GetInstance().Process(metaData_, TRACE_FLAG_DEFAULT);
-    if (stopCallback_ != nullptr) {
+    if (destroyContextFlag_ && stopCallback_ != nullptr) {
         stopCallback_();
     }
 }
@@ -160,6 +160,13 @@ void ContextCallbackImpl::HandleAuthSuccessResult(int32_t resultCode, const Attr
         static_cast<AuthType>(metaData_.authType.value()), metaData_.callerType.value(), metaData_.callerName.value());
 }
 
+void ContextCallbackImpl::OnClear()
+{
+    if (stopCallback_ != nullptr) {
+        stopCallback_();
+    }
+}
+
 void ContextCallbackImpl::SetTraceUserId(int32_t userId)
 {
     metaData_.userId = userId;
@@ -255,6 +262,11 @@ void ContextCallbackImpl::SetTraceIsBackgroundApplication(bool isBackgroundAppli
     metaData_.isBackgroundApplication = isBackgroundApplication;
 }
 
+void ContextCallbackImpl::SetDestroyContextFlag(bool destroyContextFlag)
+{
+    destroyContextFlag_ = destroyContextFlag;
+}
+
 void ContextCallbackImpl::SetCleaner(Context::ContextStopCallback callback)
 {
     stopCallback_ = callback;
@@ -338,4 +350,4 @@ std::shared_ptr<ContextCallback> ContextCallback::NewDummyInstance(OperationType
 }
 } // namespace UserAuth
 } // namespace UserIam
-} // namespace OHOS
\ No newline at end of file
+} // namespace OHOS
diff --git a/services/context/src/context_callback_impl.h b/services/context/src/context_callback_impl.h
index d87d7a0253b980ecc556d9237a109cf26d0b42b2..a324d47f610244505754f0a8c316ce84d0574e04 100644
--- a/services/context/src/context_callback_impl.h
+++ b/services/context/src/context_callback_impl.h
@@ -30,6 +30,7 @@ public:
     ~ContextCallbackImpl() override = default;
     void OnResult(int32_t resultCode, const Attributes &finalResult) override;
     void OnAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector<uint8_t> &acquireMsg) override;
+    void OnClear() override;
     void SetTraceCallerName(const std::string &callerName) override;
     void SetTraceRequestContextId(uint64_t requestContextId) override;
     void SetTraceAuthContextId(uint64_t authContextId) override;
@@ -50,6 +51,7 @@ public:
     void SetTraceAuthFinishReason(const std::string &authFinishReason) override;
     void SetTraceIsBackgroundApplication(bool isBackgroundApplication) override;
     void SetCleaner(Context::ContextStopCallback callback) override;
+    void SetDestroyContextFlag(bool destroyContextFlag) override;
     int32_t ParseAuthTipInfo(int32_t tip, const std::vector<uint8_t> &extraInfo,
         int32_t &authResult, int32_t &freezingTime) override;
     void ProcessAuthResult(int32_t tip, const std::vector<uint8_t> &extraInfo) override;
@@ -62,8 +64,9 @@ private:
     Context::ContextStopCallback stopCallback_ {nullptr};
     ContextCallbackNotifyListener::MetaData metaData_;
     std::shared_ptr<IamHitraceHelper> iamHitraceHelper_;
+    bool destroyContextFlag_ {true};
 };
 } // namespace UserAuth
 } // namespace UserIam
 } // namespace OHOS
-#endif // CONTEXT_CALLBACK_IMPL_H
\ No newline at end of file
+#endif // CONTEXT_CALLBACK_IMPL_H
diff --git a/services/context/src/widget_client.cpp b/services/context/src/widget_client.cpp
index b3ea698563c45a6367954e1788058c546e5d6a37..78891d07c7ed74c0048697c38d4a9e6b87f24c3a 100644
--- a/services/context/src/widget_client.cpp
+++ b/services/context/src/widget_client.cpp
@@ -119,8 +119,7 @@ void WidgetClient::ProcessNotice(const WidgetNotice &notice, std::vector<AuthTyp
     } else if (notice.event == EVENT_AUTH_WIDGET_LOADED) {
         schedule_->SendAuthTipInfo(authTypeList, TIP_CODE_WIDGET_LOADED);
     } else if (notice.event == EVENT_AUTH_WIDGET_RELEASED) {
-        schedule_->SendAuthTipInfo(authTypeList, TIP_CODE_WIDGET_RELEASED);
-        schedule_->SendAuthResult();
+        ProcWidgetRelease(authTypeList);
     }
 }
 
@@ -204,7 +203,9 @@ void WidgetClient::SetWidgetParam(const WidgetParamInner &param)
 
 void WidgetClient::SetAuthTypeList(const std::vector<AuthType> &authTypeList)
 {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     authTypeList_ = authTypeList;
+    curAuthTypeList_ = authTypeList;
 }
 
 void WidgetClient::SetWidgetCallback(const sptr<IWidgetCallback> &callback)
@@ -225,7 +226,7 @@ uint32_t WidgetClient::GetAuthTokenId() const
 
 void WidgetClient::Reset()
 {
-    IAM_LOGD("WidgetClient Reset");
+    IAM_LOGI("WidgetClient Reset");
     widgetParam_.title.clear();
     widgetParam_.navigationButtonText.clear();
     widgetParam_.windowMode = WindowModeType::DIALOG_BOX;
@@ -335,6 +336,28 @@ void WidgetClient::SetCallingBundleName(const std::string &callingBundleName)
 {
     callingBundleName_ = callingBundleName;
 }
+
+void WidgetClient::ProcWidgetRelease(std::vector<AuthType> &authTypeList)
+{
+    IF_FALSE_LOGE_AND_RETURN(schedule_ != nullptr);
+    schedule_->SendAuthTipInfo(authTypeList, TIP_CODE_WIDGET_RELEASED);
+
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    for (auto &authType : authTypeList) {
+        std::vector<AuthType>::iterator it;
+        for (it = curAuthTypeList_.begin(); it != curAuthTypeList_.end();) {
+            if (*it == authType) {
+                it = curAuthTypeList_.erase(it);
+            } else {
+                it++;
+            }
+        }
+    }
+
+    if (curAuthTypeList_.empty()) {
+        schedule_->ClearSchedule();
+    }
+}
 } // namespace UserAuth
 } // namespace UserIam
-} // namespace OHOS
\ No newline at end of file
+} // namespace OHOS
diff --git a/services/context/src/widget_context.cpp b/services/context/src/widget_context.cpp
index 74612a3f271503e857f0d5d70ea7405ad1801fb1..2eb865f07aff9f48f0931edef8888c9698acb3ca 100644
--- a/services/context/src/widget_context.cpp
+++ b/services/context/src/widget_context.cpp
@@ -66,7 +66,7 @@ const std::string TO_PORTRAIT = "90";
 const std::string TO_INVERTED = "180";
 const std::string TO_PORTRAIT_INVERTED = "270";
 const std::string SUPPORT_FOLLOW_CALLER_UI = "const.useriam.authWidget.supportFollowCallerUi";
-static constexpr uint32_t RESULT_TIMER_LEN_MS = 100;
+static constexpr uint32_t CLEAR_TIMER_LEN_MS = 1000;
 
 WidgetContext::WidgetContext(uint64_t contextId, const ContextFactory::AuthWidgetContextPara &para,
     std::shared_ptr<ContextCallback> callback, const sptr<IModalCallback> &modalCallback)
@@ -242,6 +242,10 @@ bool WidgetContext::OnStart()
 void WidgetContext::OnResult(int32_t resultCode, const std::shared_ptr<Attributes> &scheduleResultAttr)
 {
     IAM_LOGI("%{public}s receive result code %{public}d", description_.c_str(), resultCode);
+    IF_FALSE_LOGE_AND_RETURN(scheduleResultAttr != nullptr);
+    IF_FALSE_LOGE_AND_RETURN(callerCallback_ != nullptr);
+    callerCallback_->OnResult(resultCode, *scheduleResultAttr);
+    StartClearTimer();
 }
 
 bool WidgetContext::OnStop()
@@ -423,6 +427,7 @@ void WidgetContext::StopAuthList(const std::vector<AuthType> &authTypeList)
             runTaskInfoList_.erase(it);
         }
     }
+    StopClearTimer();
 }
 
 void WidgetContext::SuccessAuth(AuthType authType)
@@ -542,6 +547,7 @@ bool WidgetContext::ConnectExtension(const WidgetRotatePara &widgetRotatePara)
     if (IsSingleFaceOrFingerPrintAuth() && para_.skipLockedBiometricAuth &&
         para_.authProfileMap[para_.authTypeList[0]].remainTimes == 0) {
         Attributes attr;
+        IF_FALSE_LOGE_AND_RETURN_VAL(callerCallback_ != nullptr, false);
         callerCallback_->OnResult(ResultCode::LOCKED, attr);
         return true;
     }
@@ -617,38 +623,39 @@ void WidgetContext::End(const ResultCode &resultCode)
     IAM_LOGD("in End, resultCode: %{public}d", static_cast<int32_t>(resultCode));
     StopAllRunTask(resultCode);
     IF_FALSE_LOGE_AND_RETURN(callerCallback_ != nullptr);
-    Attributes attr;
+    std::shared_ptr<Attributes> attr = Common::MakeShared<Attributes>();
+    IF_FALSE_LOGE_AND_RETURN(attr != nullptr);
     if (resultCode == ResultCode::SUCCESS || authResultInfo_.token.size() != 0) {
-        if (!attr.SetInt32Value(Attributes::ATTR_AUTH_TYPE, authResultInfo_.authType)) {
+        if (!attr->SetInt32Value(Attributes::ATTR_AUTH_TYPE, authResultInfo_.authType)) {
             IAM_LOGE("set auth type failed.");
             callerCallback_->SetTraceAuthFinishReason("WidgetContext End set authType fail");
-            callerCallback_->OnResult(ResultCode::GENERAL_ERROR, attr);
+            OnResult(ResultCode::GENERAL_ERROR, attr);
             return;
         }
         if (authResultInfo_.token.size() > 0) {
-            if (!attr.SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, authResultInfo_.token)) {
+            if (!attr->SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, authResultInfo_.token)) {
                 IAM_LOGE("set signature token failed.");
                 callerCallback_->SetTraceAuthFinishReason("WidgetContext End set token fail");
-                callerCallback_->OnResult(ResultCode::GENERAL_ERROR, attr);
+                OnResult(ResultCode::GENERAL_ERROR, attr);
                 return;
             }
         }
         IAM_LOGI("in End, token size: %{public}zu.", authResultInfo_.token.size());
-        if (!attr.SetUint64Value(Attributes::ATTR_CREDENTIAL_DIGEST, authResultInfo_.credentialDigest)) {
+        if (!attr->SetUint64Value(Attributes::ATTR_CREDENTIAL_DIGEST, authResultInfo_.credentialDigest)) {
             IAM_LOGE("set credential digest failed.");
             callerCallback_->SetTraceAuthFinishReason("WidgetContext End set credentialDigest fail");
-            callerCallback_->OnResult(ResultCode::GENERAL_ERROR, attr);
+            OnResult(ResultCode::GENERAL_ERROR, attr);
             return;
         }
-        if (!attr.SetUint16Value(Attributes::ATTR_CREDENTIAL_COUNT, authResultInfo_.credentialCount)) {
+        if (!attr->SetUint16Value(Attributes::ATTR_CREDENTIAL_COUNT, authResultInfo_.credentialCount)) {
             IAM_LOGE("set credential count failed.");
             callerCallback_->SetTraceAuthFinishReason("WidgetContext End set credentialCount fail");
-            callerCallback_->OnResult(ResultCode::GENERAL_ERROR, attr);
+            OnResult(ResultCode::GENERAL_ERROR, attr);
             return;
         }
     }
     callerCallback_->SetTraceAuthFinishReason("WidgetContext End fail");
-    callerCallback_->OnResult(resultCode, attr);
+    OnResult(resultCode, attr);
 }
 
 void WidgetContext::StopAllRunTask(const ResultCode &resultCode)
@@ -669,7 +676,6 @@ void WidgetContext::StopAllRunTask(const ResultCode &resultCode)
             IAM_LOGE("failed to release launch widget.");
         }
     }
-    WidgetClient::Instance().Reset();
 }
 
 void WidgetContext::BuildStartPinSubType(WidgetCmdParameters &widgetCmdParameters)
@@ -815,6 +821,7 @@ void WidgetContext::ProcAuthResult(int32_t resultCode, AuthType authType, int32_
     const Attributes &finalResult)
 {
     IAM_LOGI("recv task result: %{public}d, authType: %{public}d", resultCode, authType);
+    IF_FALSE_LOGE_AND_RETURN(schedule_ != nullptr);
     if (resultCode == ResultCode::SUCCESS || resultCode == ResultCode::COMPLEXITY_CHECK_FAILED) {
         finalResult.GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, authResultInfo_.token);
         finalResult.GetUint64Value(Attributes::ATTR_CREDENTIAL_DIGEST, authResultInfo_.credentialDigest);
@@ -824,18 +831,28 @@ void WidgetContext::ProcAuthResult(int32_t resultCode, AuthType authType, int32_
         if (resultCode != ResultCode::SUCCESS) {
             SetLatestError(resultCode);
         }
+        schedule_->SuccessAuth(authType);
     } else {
         SetLatestError(resultCode);
         if (resultCode != ResultCode::CANCELED) {
             SendAuthTipInfo(authType, GetAuthTipCode(resultCode, freezingTime));
         }
+        if (para_.skipLockedBiometricAuth && freezingTime > 0) {
+            if (IsSingleFaceOrFingerPrintAuth()) {
+                schedule_->FailAuth(authType);
+            } else if (IsNavigationAuth()) {
+                schedule_->NaviPinAuth();
+            }
+        } else {
+            schedule_->StopAuthList({authType});
+        }
     }
-    StartOnResultTimer(resultCode, authType, freezingTime);
 }
 
 void WidgetContext::ProcAuthTipInfo(int32_t tip, AuthType authType, const std::vector<uint8_t> &extraInfo)
 {
     IAM_LOGI("authType:%{public}d, tip:%{public}d", authType, tip);
+    IF_FALSE_LOGE_AND_RETURN(schedule_ != nullptr);
     IF_FALSE_LOGE_AND_RETURN(callerCallback_ != nullptr);
     int32_t resultCode = ResultCode::GENERAL_ERROR;
     int32_t freezingTime = -1;
@@ -850,127 +867,64 @@ void WidgetContext::ProcAuthTipInfo(int32_t tip, AuthType authType, const std::v
     if (resultCode != ResultCode::CANCELED) {
         SendAuthTipInfo(authType, GetAuthTipCode(resultCode, freezingTime));
     }
-    StartOnTipTimer(authType, freezingTime);
-}
-
-void WidgetContext::StartOnResultTimer(int32_t resultCode, AuthType authType, int32_t freezingTime)
-{
-    IAM_LOGI("start");
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
-    resultInfo_.resultCode = resultCode;
-    resultInfo_.authType = authType;
-    resultInfo_.freezingTime = freezingTime;
-    if (onResultTimerId_ != 0) {
-        IAM_LOGI("onResult timer is already start");
-        return;
-    }
-
-    onResultTimerId_ = RelativeTimer::GetInstance().Register(
-        [weakSelf = weak_from_this(), resultCode, authType, freezingTime] {
-            auto self = weakSelf.lock();
-            if (self == nullptr) {
-                IAM_LOGE("context is released");
-                return;
-            }
-            self->OnResultTimerTimeOut(resultCode, authType, freezingTime);
-        },
-        RESULT_TIMER_LEN_MS);
-}
-
-void WidgetContext::StopOnResultTimer()
-{
-    IAM_LOGI("start");
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
-    if (onResultTimerId_ == 0) {
-        IAM_LOGI("onResult timer is already stop");
-        return;
+    if (para_.skipLockedBiometricAuth && freezingTime > 0) {
+        if (IsSingleFaceOrFingerPrintAuth()) {
+            schedule_->FailAuth(authType);
+        } else if (IsNavigationAuth()) {
+            schedule_->NaviPinAuth();
+        }
     }
-
-    RelativeTimer::GetInstance().Unregister(onResultTimerId_);
-    onResultTimerId_ = 0;
 }
 
-void WidgetContext::OnResultTimerTimeOut(int32_t resultCode, AuthType authType, int32_t freezingTime)
+void WidgetContext::ClearSchedule()
 {
     IAM_LOGI("start");
-    IF_FALSE_LOGE_AND_RETURN(schedule_ != nullptr);
-    if (resultCode == ResultCode::SUCCESS || resultCode == ResultCode::COMPLEXITY_CHECK_FAILED) {
-        schedule_->SuccessAuth(authType);
-    } else {
-        if (para_.skipLockedBiometricAuth && freezingTime > 0) {
-            if (IsSingleFaceOrFingerPrintAuth()) {
-                schedule_->FailAuth(authType);
-            } else if (IsNavigationAuth()) {
-                schedule_->NaviPinAuth();
-            }
-        } else {
-            schedule_->StopAuthList({authType});
-        }
-    }
+    WidgetClient::Instance().Reset();
+    OnClearTimeOut();
+    StopClearTimer();
 }
 
-void WidgetContext::StartOnTipTimer(AuthType authType, int32_t freezingTime)
+void WidgetContext::StartClearTimer()
 {
     IAM_LOGI("start");
     std::lock_guard<std::recursive_mutex> lock(mutex_);
-    resultInfo_.resultCode = FAIL;
-    resultInfo_.authType = authType;
-    resultInfo_.freezingTime = freezingTime;
-    if (onTipTimerId_ != 0) {
-        IAM_LOGI("onTip timer is already start");
+    if (clearTimerId_ != 0) {
+        IAM_LOGI("clear timer is already start");
         return;
     }
 
-    onTipTimerId_ = RelativeTimer::GetInstance().Register(
-        [weakSelf = weak_from_this(), authType, freezingTime] {
+    clearTimerId_ = RelativeTimer::GetInstance().Register(
+        [weakSelf = weak_from_this()] {
             auto self = weakSelf.lock();
             if (self == nullptr) {
                 IAM_LOGE("context is released");
                 return;
             }
-            self->OnTipTimerTimeOut(authType, freezingTime);
+            self->OnClearTimeOut();
         },
-        RESULT_TIMER_LEN_MS);
+        CLEAR_TIMER_LEN_MS);
 }
 
-void WidgetContext::StopOnTipTimer()
+void WidgetContext::StopClearTimer()
 {
     IAM_LOGI("start");
     std::lock_guard<std::recursive_mutex> lock(mutex_);
-    if (onTipTimerId_ == 0) {
-        IAM_LOGI("onTip timer is already stop");
+    if (clearTimerId_ == 0) {
+        IAM_LOGI("clear timer is already stop");
         return;
     }
 
-    RelativeTimer::GetInstance().Unregister(onTipTimerId_);
-    onTipTimerId_ = 0;
-}
-
-void WidgetContext::OnTipTimerTimeOut(AuthType authType, int32_t freezingTime)
-{
-    IAM_LOGI("start");
-    IF_FALSE_LOGE_AND_RETURN(schedule_ != nullptr);
-    if (para_.skipLockedBiometricAuth && freezingTime > 0) {
-        if (IsSingleFaceOrFingerPrintAuth()) {
-            schedule_->FailAuth(authType);
-        } else if (IsNavigationAuth()) {
-            schedule_->NaviPinAuth();
-        }
-    }
+    RelativeTimer::GetInstance().Unregister(clearTimerId_);
+    clearTimerId_ = 0;
 }
 
-void WidgetContext::SendAuthResult()
+void WidgetContext::OnClearTimeOut()
 {
     IAM_LOGI("start");
+    IF_FALSE_LOGE_AND_RETURN(callerCallback_ != nullptr);
     std::lock_guard<std::recursive_mutex> lock(mutex_);
-    if (onTipTimerId_ != 0 && resultInfo_.resultCode != SUCCESS) {
-        OnTipTimerTimeOut(resultInfo_.authType, resultInfo_.freezingTime);
-        StopOnTipTimer();
-    }
-
-    if (onResultTimerId_ != 0) {
-        OnResultTimerTimeOut(resultInfo_.resultCode, resultInfo_.authType, resultInfo_.freezingTime);
-        StopOnResultTimer();
+    if (clearTimerId_ != 0) {
+        callerCallback_->OnClear();
     }
 }
 } // namespace UserAuth
diff --git a/services/core/inc/widget_schedule_node.h b/services/core/inc/widget_schedule_node.h
index fb16dcd8f040dc19f10ec034f7400a61b56f6e0c..471742c5c4e17f05a63dd1dfe09c00850232e750 100644
--- a/services/core/inc/widget_schedule_node.h
+++ b/services/core/inc/widget_schedule_node.h
@@ -51,6 +51,7 @@ public:
         E_WIDGET_PARA_INVALID = 6,
         E_WIDGET_RELOAD = 7,
         E_STOP_AUTH = 8,
+        E_CLEAR_AUTH = 9,
     };
 
     virtual ~WidgetScheduleNode() = default;
@@ -67,9 +68,9 @@ public:
         AuthType &rotateAuthType) = 0;
     virtual void SetCallback(std::shared_ptr<WidgetScheduleNodeCallback> callback) = 0;
     virtual void SendAuthTipInfo(const std::vector<AuthType> &authTypeList, int32_t tipCode) = 0;
-    virtual void SendAuthResult() = 0;
+    virtual bool ClearSchedule() = 0;
 };
 } // namespace UserAuth
 } // namespace UserIam
 } // namespace OHOS
-#endif // IAM_WIDGET_SCHEDULE_NODE_H
\ No newline at end of file
+#endif // IAM_WIDGET_SCHEDULE_NODE_H
diff --git a/services/core/inc/widget_schedule_node_callback.h b/services/core/inc/widget_schedule_node_callback.h
index 2f409317f5fcd3a452dd229a6ac643a1909676a1..2c64b092be09d5ebc5a6300bb7b9b4ee7dcbc515 100644
--- a/services/core/inc/widget_schedule_node_callback.h
+++ b/services/core/inc/widget_schedule_node_callback.h
@@ -44,7 +44,7 @@ public:
         AuthType &rotateAuthType) = 0;
     virtual void AuthWidgetReloadInit() = 0;
     virtual void SendAuthTipInfo(int32_t authType, int32_t tipInfo) = 0;
-    virtual void SendAuthResult() = 0;
+    virtual void ClearSchedule() = 0;
 };
 } // namespace UserAuth
 } // namespace UserIam
diff --git a/services/core/src/widget_schedule_node_impl.cpp b/services/core/src/widget_schedule_node_impl.cpp
index 0f6cf98c52b1fc5e5efd85264660118494311a42..5a65bbc565007b6e94e5c560450a7362f1d175d9 100644
--- a/services/core/src/widget_schedule_node_impl.cpp
+++ b/services/core/src/widget_schedule_node_impl.cpp
@@ -80,6 +80,13 @@ std::shared_ptr<FiniteStateMachine> WidgetScheduleNodeImpl::MakeFiniteStateMachi
     builder->MakeTransition(S_WIDGET_RELOAD_WAITING, E_CANCEL_AUTH, S_WIDGET_WAITING,
         [this](FiniteStateMachine &machine, uint32_t event) { OnWidgetReload(machine, event); });
 
+    builder->MakeTransition(S_WIDGET_WAITING, E_CLEAR_AUTH, S_WIDGET_INIT,
+        [this](FiniteStateMachine &machine, uint32_t event) { OnClearSchedule(machine, event); });
+    builder->MakeTransition(S_WIDGET_AUTH_RUNNING, E_CLEAR_AUTH, S_WIDGET_INIT,
+        [this](FiniteStateMachine &machine, uint32_t event) { OnClearSchedule(machine, event); });
+    builder->MakeTransition(S_WIDGET_AUTH_FINISHED, E_CLEAR_AUTH, S_WIDGET_INIT,
+        [this](FiniteStateMachine &machine, uint32_t event) { OnClearSchedule(machine, event); });
+
     return builder->Build();
 }
 
@@ -111,6 +118,12 @@ bool WidgetScheduleNodeImpl::StopSchedule()
     return TryKickMachine(E_CANCEL_AUTH);
 }
 
+bool WidgetScheduleNodeImpl::ClearSchedule()
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+    return TryKickMachine(E_CLEAR_AUTH);
+}
+
 bool WidgetScheduleNodeImpl::StartAuthList(const std::vector<AuthType> &authTypeList, bool endAfterFirstFail,
     AuthIntent authIntent)
 {
@@ -269,23 +282,23 @@ void WidgetScheduleNodeImpl::OnWidgetReload(FiniteStateMachine &machine, uint32_
     }
 }
 
-void WidgetScheduleNodeImpl::SendAuthTipInfo(const std::vector<AuthType> &authTypeList, int32_t tipCode)
+void WidgetScheduleNodeImpl::OnClearSchedule(FiniteStateMachine &machine, uint32_t event)
 {
     auto callback = callback_.lock();
     IF_FALSE_LOGE_AND_RETURN(callback != nullptr);
-    IAM_LOGI("send mid auth result");
-    for (auto &authType : authTypeList) {
-        callback->SendAuthTipInfo(authType, tipCode);
-    }
+    IAM_LOGI("clear schedule");
+    callback->ClearSchedule();
 }
 
-void WidgetScheduleNodeImpl::SendAuthResult()
+void WidgetScheduleNodeImpl::SendAuthTipInfo(const std::vector<AuthType> &authTypeList, int32_t tipCode)
 {
     auto callback = callback_.lock();
     IF_FALSE_LOGE_AND_RETURN(callback != nullptr);
-    IAM_LOGI("send auth result");
-    callback->SendAuthResult();
+    IAM_LOGI("send mid auth result");
+    for (auto &authType : authTypeList) {
+        callback->SendAuthTipInfo(authType, tipCode);
+    }
 }
 } // namespace UserAuth
 } // namespace UserIam
-} // namespace OHOS
\ No newline at end of file
+} // namespace OHOS
diff --git a/services/core/src/widget_schedule_node_impl.h b/services/core/src/widget_schedule_node_impl.h
index 69456e0ad8d3c0b105bae749c284e9ef8767f2de..ec8ee7228b3e4a41e26ad3f2f8918696566a1030 100644
--- a/services/core/src/widget_schedule_node_impl.h
+++ b/services/core/src/widget_schedule_node_impl.h
@@ -50,7 +50,7 @@ public:
         AuthType &rotateAuthType) override;
     void SetCallback(std::shared_ptr<WidgetScheduleNodeCallback> callback) override;
     void SendAuthTipInfo(const std::vector<AuthType> &authTypeList, int32_t tipCode) override;
-    void SendAuthResult() override;
+    bool ClearSchedule() override;
 
 protected:
     void OnStartSchedule(FiniteStateMachine &machine, uint32_t event);
@@ -63,6 +63,7 @@ protected:
     void OnWidgetReload(FiniteStateMachine &machine, uint32_t event);
     void OnWidgetReloadInit(FiniteStateMachine &machine, uint32_t event);
     void OnFailAuth(FiniteStateMachine &machine, uint32_t event);
+    void OnClearSchedule(FiniteStateMachine &machine, uint32_t event);
 
 private:
     std::shared_ptr<FiniteStateMachine> MakeFiniteStateMachine();
@@ -89,4 +90,4 @@ private:
 } // namespace UserAuth
 } // namespace UserIam
 } // namespace OHOS
-#endif // IAM_WIDGET_SCHEDULE_NODE_IMPL_H
\ No newline at end of file
+#endif // IAM_WIDGET_SCHEDULE_NODE_IMPL_H
diff --git a/services/ipc/src/user_auth_service.cpp b/services/ipc/src/user_auth_service.cpp
index 0eee2ac1f7cdec1412593bcb05692f93a7c323cf..4ed18742b17daeb95726d9b7cd983b9bd43115b7 100644
--- a/services/ipc/src/user_auth_service.cpp
+++ b/services/ipc/src/user_auth_service.cpp
@@ -1172,6 +1172,7 @@ uint64_t UserAuthService::StartWidgetContext(const std::shared_ptr<ContextCallba
     }
     contextCallback->SetTraceRequestContextId(context->GetContextId());
     contextCallback->SetCleaner(ContextHelper::Cleaner(context));
+    contextCallback->SetDestroyContextFlag(false);
     if (!context->Start()) {
         int32_t errorCode = context->GetLatestError();
         IAM_LOGE("start widget context fail %{public}d", errorCode);
diff --git a/test/unittest/services/mocks/mock_context.h b/test/unittest/services/mocks/mock_context.h
index a1045daa45f47c554adbe42435b9ef1456567a13..165fa52c7c3dcf16b807d4d61e88b5f0be447b14 100644
--- a/test/unittest/services/mocks/mock_context.h
+++ b/test/unittest/services/mocks/mock_context.h
@@ -62,6 +62,8 @@ public:
     MOCK_METHOD1(SetTraceConnectionName, void(const std::string &connectionName));
     MOCK_METHOD1(SetTraceAuthFinishReason, void(const std::string &authFinishReason));
     MOCK_METHOD1(SetTraceIsBackgroundApplication, void(const bool isBackgroundApplication));
+    MOCK_METHOD1(SetDestroyContextFlag, void(bool destroyContextFlag));
+    MOCK_METHOD0(OnClear, void());
 };
 
 class MockContext final : public Context {
@@ -142,4 +144,4 @@ protected:
 } // namespace UserAuth
 } // namespace UserIam
 } // namespace OHOS
-#endif // IAM_MOCK_CONTEXT_H
\ No newline at end of file
+#endif // IAM_MOCK_CONTEXT_H
diff --git a/test/unittest/services/mocks/mock_widget_schedule_node.h b/test/unittest/services/mocks/mock_widget_schedule_node.h
index 5b7a15550782b802ac8e418baf542ae22e0a8698..274f53dbf1a398377938f1dba7fb6c68fbf58a93 100644
--- a/test/unittest/services/mocks/mock_widget_schedule_node.h
+++ b/test/unittest/services/mocks/mock_widget_schedule_node.h
@@ -37,7 +37,7 @@ public:
     MOCK_METHOD4(WidgetReload, bool(uint32_t orientation, uint32_t needRotate, uint32_t alreadyLoad,
         AuthType &rotateAuthType));
     MOCK_METHOD2(SendAuthTipInfo, void(const std::vector<AuthType> &authTypeList, int32_t tipCode));
-    MOCK_METHOD0(SendAuthResult, void());
+    MOCK_METHOD0(ClearSchedule, bool());
 };
 } // namespace UserAuth
 } // namespace UserIam
diff --git a/test/unittest/services/mocks/mock_widget_schedule_node_callback.h b/test/unittest/services/mocks/mock_widget_schedule_node_callback.h
index 4963fa6ffcf4642587eb66d8b9c5d974cf53bb76..79b072cdbccc9297840361c481731c9b88e6792d 100644
--- a/test/unittest/services/mocks/mock_widget_schedule_node_callback.h
+++ b/test/unittest/services/mocks/mock_widget_schedule_node_callback.h
@@ -37,7 +37,7 @@ public:
     MOCK_METHOD1(SuccessAuth, void(AuthType authType));
     MOCK_METHOD1(FailAuth, void(AuthType authType));
     MOCK_METHOD2(SendAuthTipInfo, void(int32_t authType, int32_t tipInfo));
-    MOCK_METHOD0(SendAuthResult, void());
+    MOCK_METHOD0(ClearSchedule, void());
     MOCK_METHOD4(AuthWidgetReload, bool(uint32_t orientation, uint32_t needRotate, uint32_t alreadyLoad,
         AuthType &rotateAuthType));
     MOCK_METHOD0(AuthWidgetReloadInit, void());
diff --git a/test/unittest/services/src/widget_context_test.cpp b/test/unittest/services/src/widget_context_test.cpp
index 19f3e0c0d99ed172771b6101ae588cf78837a32c..e67056688d2a6073e4968cea6b72c03f026d2f77 100644
--- a/test/unittest/services/src/widget_context_test.cpp
+++ b/test/unittest/services/src/widget_context_test.cpp
@@ -718,110 +718,50 @@ HWTEST_F(WidgetContextTest, WidgetContextTestProcAuthTipInfo, TestSize.Level0)
     EXPECT_NO_THROW(widgetContext->ProcAuthTipInfo(0, PIN, extraInfo));
 }
 
-HWTEST_F(WidgetContextTest, WidgetContextTestStopOnResultTimer, TestSize.Level0)
-{
-    uint64_t contextId = 1;
-    ContextFactory::AuthWidgetContextPara para;
-    auto widgetContext = CreateWidgetContext(contextId, para);
-    EXPECT_NE(widgetContext, nullptr);
-    EXPECT_NO_THROW(widgetContext->StopOnResultTimer());
-    widgetContext->onResultTimerId_ = 1;
-    EXPECT_NO_THROW(widgetContext->StopOnResultTimer());
-}
-
-HWTEST_F(WidgetContextTest, WidgetContextTestOnResultTimerTimeOut, TestSize.Level0)
-{
-    uint64_t contextId = 1;
-    ContextFactory::AuthWidgetContextPara para;
-    auto widgetContext = CreateWidgetContext(contextId, para);
-    int32_t resultCode = 0;
-    AuthType authType = AuthType::ALL;
-    int32_t freezingTime = 0;
-    widgetContext->BuildSchedule();
-    EXPECT_NO_THROW(widgetContext->OnResultTimerTimeOut(resultCode, authType, freezingTime));
-    resultCode = 1;
-    EXPECT_NO_THROW(widgetContext->OnResultTimerTimeOut(resultCode, authType, freezingTime));
-    freezingTime = 1;
-    widgetContext->para_.skipLockedBiometricAuth = true;
-    EXPECT_NO_THROW(widgetContext->OnResultTimerTimeOut(resultCode, authType, freezingTime));
-    widgetContext->para_.widgetParam.navigationButtonText = "1";
-    EXPECT_NO_THROW(widgetContext->OnResultTimerTimeOut(resultCode, authType, freezingTime));
-    widgetContext->para_.widgetParam.navigationButtonText = "";
-    authType = AuthType::FACE;
-    widgetContext->para_.authTypeList.emplace_back(authType);
-    EXPECT_NO_THROW(widgetContext->OnResultTimerTimeOut(resultCode, authType, freezingTime));
-}
-
-HWTEST_F(WidgetContextTest, WidgetContextTestStopOnTipTimer, TestSize.Level0)
+HWTEST_F(WidgetContextTest, WidgetContextTestSetSysDialogZOrder, TestSize.Level0)
 {
     uint64_t contextId = 1;
     ContextFactory::AuthWidgetContextPara para;
     auto widgetContext = CreateWidgetContext(contextId, para);
     EXPECT_NE(widgetContext, nullptr);
-    EXPECT_NO_THROW(widgetContext->StopOnTipTimer());
-    widgetContext->onTipTimerId_ = 1;
-    EXPECT_NO_THROW(widgetContext->StopOnTipTimer());
+    WidgetCmdParameters widgetCmdParameters = {};
+    EXPECT_NO_THROW(widgetContext->SetSysDialogZOrder(widgetCmdParameters));
+    widgetContext->para_.callerName = "findnetwork";
+    widgetContext->para_.callerType = Security::AccessToken::TOKEN_NATIVE;
+    EXPECT_NO_THROW(widgetContext->SetSysDialogZOrder(widgetCmdParameters));
 }
 
-HWTEST_F(WidgetContextTest, WidgetContextTestOnTipTimerTimeOut, TestSize.Level0)
+HWTEST_F(WidgetContextTest, WidgetContextTestConnectExtension, TestSize.Level0)
 {
     uint64_t contextId = 1;
     ContextFactory::AuthWidgetContextPara para;
     auto widgetContext = CreateWidgetContext(contextId, para);
     EXPECT_NE(widgetContext, nullptr);
-    AuthType authType = AuthType::ALL;
-    int32_t freezingTime = 0;
-    widgetContext->BuildSchedule();
-    EXPECT_NO_THROW(widgetContext->OnTipTimerTimeOut(authType, freezingTime));
-    widgetContext->para_.skipLockedBiometricAuth = true;
-    freezingTime = 1;
-    EXPECT_NO_THROW(widgetContext->OnTipTimerTimeOut(authType, freezingTime));
-    widgetContext->para_.widgetParam.navigationButtonText = "1";
-    EXPECT_NO_THROW(widgetContext->OnTipTimerTimeOut(authType, freezingTime));
-    widgetContext->para_.widgetParam.navigationButtonText = "";
-    authType = AuthType::FACE;
+    WidgetContext::WidgetRotatePara widgetRotatePara = {};
+    widgetRotatePara.isReload = true;
+    AuthType authType = AuthType::FACE;
     widgetContext->para_.authTypeList.emplace_back(authType);
-    EXPECT_NO_THROW(widgetContext->OnTipTimerTimeOut(authType, freezingTime));
-}
-
-HWTEST_F(WidgetContextTest, WidgetContextTestSendAuthResult, TestSize.Level0)
-{
-    uint64_t contextId = 1;
-    ContextFactory::AuthWidgetContextPara para;
-    auto widgetContext = CreateWidgetContext(contextId, para);
-    EXPECT_NE(widgetContext, nullptr);
-    EXPECT_NO_THROW(widgetContext->SendAuthResult());
-    widgetContext->onTipTimerId_ = 1;
-    widgetContext->resultInfo_.resultCode = 1;
-    EXPECT_NO_THROW(widgetContext->SendAuthResult());
-    widgetContext->onResultTimerId_ = 1;
-    EXPECT_NO_THROW(widgetContext->SendAuthResult());
+    EXPECT_EQ(widgetContext->ConnectExtension(widgetRotatePara), false);
 }
 
-HWTEST_F(WidgetContextTest, WidgetContextTestSetSysDialogZOrder, TestSize.Level0)
+HWTEST_F(WidgetContextTest, WidgetContextTestSelfDestructTimer, TestSize.Level0)
 {
     uint64_t contextId = 1;
     ContextFactory::AuthWidgetContextPara para;
     auto widgetContext = CreateWidgetContext(contextId, para);
     EXPECT_NE(widgetContext, nullptr);
-    WidgetCmdParameters widgetCmdParameters = {};
-    EXPECT_NO_THROW(widgetContext->SetSysDialogZOrder(widgetCmdParameters));
-    widgetContext->para_.callerName = "findnetwork";
-    widgetContext->para_.callerType = Security::AccessToken::TOKEN_NATIVE;
-    EXPECT_NO_THROW(widgetContext->SetSysDialogZOrder(widgetCmdParameters));
+    EXPECT_NO_THROW(widgetContext->StopClearTimer());
+    widgetContext->clearTimerId_ = 1;
+    EXPECT_NO_THROW(widgetContext->StopClearTimer());
 }
 
-HWTEST_F(WidgetContextTest, WidgetContextTestConnectExtension, TestSize.Level0)
+HWTEST_F(WidgetContextTest, WidgetContextTestSelfDestructTimerTimeOut, TestSize.Level0)
 {
     uint64_t contextId = 1;
     ContextFactory::AuthWidgetContextPara para;
     auto widgetContext = CreateWidgetContext(contextId, para);
-    EXPECT_NE(widgetContext, nullptr);
-    WidgetContext::WidgetRotatePara widgetRotatePara = {};
-    widgetRotatePara.isReload = true;
-    AuthType authType = AuthType::FACE;
-    widgetContext->para_.authTypeList.emplace_back(authType);
-    EXPECT_EQ(widgetContext->ConnectExtension(widgetRotatePara), false);
+    widgetContext->BuildSchedule();
+    EXPECT_NO_THROW(widgetContext->OnClearTimeOut());
 }
 } // namespace UserAuth
 } // namespace UserIam