diff --git a/frameworks/ets/ani/user_auth/idl/ohos.userIAM.userAuth.userAuth.taihe b/frameworks/ets/ani/user_auth/idl/ohos.userIAM.userAuth.userAuth.taihe
index ef8ff989b093a1194f3f8b3a8296b8c5e86b8d1f..1215437d3d06e52b44b9f659f802e92ecf0b700c 100644
--- a/frameworks/ets/ani/user_auth/idl/ohos.userIAM.userAuth.userAuth.taihe
+++ b/frameworks/ets/ani/user_auth/idl/ohos.userIAM.userAuth.userAuth.taihe
@@ -126,15 +126,17 @@ struct IAuthWidgetCallback {
 }
  
 interface UserAuthInstance {
-    on(type: String, callback: IAuthCallback): void;
-    off(type: String, callback: Optional<IAuthCallback>): void;
+    onResult(callback: IAuthCallback): void;
+    offResult(callback: Optional<IAuthCallback>): void;
     start(): void;
     cancel(): void;
+    onAuthTip(callback: (authTipInfo: AuthTipInfo) => void): void;
+    offAuthTip(callback: Optional<(authTipInfo: AuthTipInfo) => void>): void;
 }
  
 interface UserAuthWidgetMgr {
-    on(type: String, callback: IAuthWidgetCallback): void;
-    off(type: String, callback: Optional<IAuthWidgetCallback>): void;
+    onCommand(callback: IAuthWidgetCallback): void;
+    offCommand(callback: Optional<IAuthWidgetCallback>): void;
 }
  
 function GetAvailableStatus(authType: UserAuthType, authTrustLevel: AuthTrustLevel): void;
diff --git a/frameworks/ets/ani/user_auth/inc/user_auth_ani_helper.h b/frameworks/ets/ani/user_auth/inc/user_auth_ani_helper.h
index e8902012dde0d0e2e830cb24e1bfd7d0e18cded2..debebef95385c8e9488d91e36a1bfe1f3ba7db8a 100644
--- a/frameworks/ets/ani/user_auth/inc/user_auth_ani_helper.h
+++ b/frameworks/ets/ani/user_auth/inc/user_auth_ani_helper.h
@@ -34,6 +34,7 @@ public:
     static UserAuthResultCode ThrowBusinessError(UserAuthResultCode error);
     static bool VerifyNoticeParam(const std::string &eventData);
     static bool ConvertUserAuthType(int32_t userAuthType, userAuth::UserAuthType &userAuthTypeOut);
+    static bool ConvertUserAuthTipCode(int32_t userAuthTipCode, userAuth::UserAuthTipCode &userAuthTipCodeOut);
 
 private:
     UserAuthAniHelper() = default;
diff --git a/frameworks/ets/ani/user_auth/inc/user_auth_callback_v10.h b/frameworks/ets/ani/user_auth/inc/user_auth_callback_v10.h
index 40a61e2341d3eb091cbc8db4df8913c8211316c4..77faba4eef3c3ea249596d04b93f54fa87c22939 100644
--- a/frameworks/ets/ani/user_auth/inc/user_auth_callback_v10.h
+++ b/frameworks/ets/ani/user_auth/inc/user_auth_callback_v10.h
@@ -44,12 +44,18 @@ public:
     void SetResultCallback(const userAuth::IAuthCallback& resultCallback);
     void ClearResultCallback();
     bool HasResultCallback();
+    void SetTipCallback(taihe::optional<::taihe::callback<void(userAuth::AuthTipInfo const&)>> tipCallback);
+    void ClearTipCallback();
+    bool HasTipCallback();
 
 private:
     bool DoResultCallback(
         int32_t result, const std::vector<uint8_t>& token, int32_t authType, EnrolledState enrolledState);
+    bool DoTipInfoCallBack(int32_t tipType, uint32_t tipCode);
+    std::shared_ptr<taihe::optional<::taihe::callback<void(userAuth::AuthTipInfo const&)>>> GetTipCallback();
     std::mutex mutex_;
     std::shared_ptr<userAuth::IAuthCallback> resultCallback_ = nullptr;
+    std::shared_ptr<taihe::optional<::taihe::callback<void(userAuth::AuthTipInfo const&)>>> tipCallback_ = nullptr;
 };
 }  // namespace UserAuth
 }  // namespace UserIam
diff --git a/frameworks/ets/ani/user_auth/inc/user_auth_instance_v10.h b/frameworks/ets/ani/user_auth/inc/user_auth_instance_v10.h
index 4301b530a838ed13b843dfa868bdc231824a733f..4450ed5bfa414f1fa000d91f04c70675fda10300 100644
--- a/frameworks/ets/ani/user_auth/inc/user_auth_instance_v10.h
+++ b/frameworks/ets/ani/user_auth/inc/user_auth_instance_v10.h
@@ -41,10 +41,12 @@ public:
     ~UserAuthInstanceV10() = default;
 
     UserAuthResultCode Init(userAuth::AuthParam const &authParam, userAuth::WidgetParam const &widgetParam);
-    UserAuthResultCode On(std::string type, userAuth::IAuthCallback const &callback);
-    UserAuthResultCode Off(std::string type, taihe::optional_view<userAuth::IAuthCallback> callback);
+    UserAuthResultCode OnResult(userAuth::IAuthCallback const &callback);
+    UserAuthResultCode OffResult(taihe::optional_view<userAuth::IAuthCallback> callback);
     UserAuthResultCode Start();
     UserAuthResultCode Cancel();
+    UserAuthResultCode onAuthTip(taihe::callback_view<void(userAuth::AuthTipInfo const&)> callback);
+    UserAuthResultCode offAuthTip(taihe::optional_view<taihe::callback<void(userAuth::AuthTipInfo const&)>> callback);
 
 private:
     UserAuthResultCode InitAuthParam(userAuth::AuthParam const &authParam);
diff --git a/frameworks/ets/ani/user_auth/inc/user_auth_widget_mgr_v10.h b/frameworks/ets/ani/user_auth/inc/user_auth_widget_mgr_v10.h
index 6668b02e7bd1685af2b0e2f9777d8676c2a56586..940c12f278a79958ca76dfb2e39c089289fea746 100644
--- a/frameworks/ets/ani/user_auth/inc/user_auth_widget_mgr_v10.h
+++ b/frameworks/ets/ani/user_auth/inc/user_auth_widget_mgr_v10.h
@@ -38,8 +38,8 @@ public:
     ~UserAuthWidgetMgr() = default;
 
     UserAuthResultCode Init(int32_t version);
-    UserAuthResultCode On(std::string type, userAuth::IAuthWidgetCallback const &callback);
-    UserAuthResultCode Off(std::string type, taihe::optional_view<userAuth::IAuthWidgetCallback> callback);
+    UserAuthResultCode OnCommand(userAuth::IAuthWidgetCallback const &callback);
+    UserAuthResultCode OffCommand(taihe::optional_view<userAuth::IAuthWidgetCallback> callback);
 
 private:
     int32_t version_ = 1;
diff --git a/frameworks/ets/ani/user_auth/src/ohos.userIAM.userAuth.userAuth.impl.cpp b/frameworks/ets/ani/user_auth/src/ohos.userIAM.userAuth.userAuth.impl.cpp
index bddf389c1fdd7db1066deb76ed309dbf65aad810..fb869ef8281aad8b1f8eff943a74ea1be5c4b25a 100644
--- a/frameworks/ets/ani/user_auth/src/ohos.userIAM.userAuth.userAuth.impl.cpp
+++ b/frameworks/ets/ani/user_auth/src/ohos.userIAM.userAuth.userAuth.impl.cpp
@@ -61,31 +61,31 @@ public:
         }
     }
 
-    void on(string_view type, IAuthCallback const &callback)
+    void onResult(IAuthCallback const &callback)
     {
         if (userAuthInstanceV10_ == nullptr) {
             IAM_LOGE("userAuthInstanceV10_ is null");
             UserAuth::UserAuthAniHelper::ThrowBusinessError(UserAuth::UserAuthResultCode::GENERAL_ERROR);
             return;
         }
-        UserAuth::UserAuthResultCode onResult = userAuthInstanceV10_->On(type.c_str(), callback);
+        UserAuth::UserAuthResultCode onResult = userAuthInstanceV10_->OnResult(callback);
         if (onResult != UserAuth::UserAuthResultCode::SUCCESS) {
-            IAM_LOGE("userAuthInstanceV10_ on fail");
+            IAM_LOGE("userAuthInstanceV10_ onResult fail");
             UserAuth::UserAuthAniHelper::ThrowBusinessError(onResult);
             return;
         }
     }
 
-    void off(string_view type, optional_view<IAuthCallback> callback)
+    void offResult(optional_view<IAuthCallback> callback)
     {
         if (userAuthInstanceV10_ == nullptr) {
             IAM_LOGE("userAuthInstanceV10_ is null");
             UserAuth::UserAuthAniHelper::ThrowBusinessError(UserAuth::UserAuthResultCode::GENERAL_ERROR);
             return;
         }
-        UserAuth::UserAuthResultCode offResult = userAuthInstanceV10_->Off(type.c_str(), callback);
+        UserAuth::UserAuthResultCode offResult = userAuthInstanceV10_->OffResult(callback);
         if (offResult != UserAuth::UserAuthResultCode::SUCCESS) {
-            IAM_LOGE("userAuthInstanceV10_ off fail");
+            IAM_LOGE("userAuthInstanceV10_ offResult fail");
             UserAuth::UserAuthAniHelper::ThrowBusinessError(offResult);
             return;
         }
@@ -121,6 +121,34 @@ public:
         }
     }
 
+    void onAuthTip(callback_view<void(AuthTipInfo const&)> callback) {
+        if (userAuthInstanceV10_ == nullptr) {
+            IAM_LOGE("userAuthInstanceV10_ is null");
+            UserAuth::UserAuthAniHelper::ThrowBusinessError(UserAuth::UserAuthResultCode::GENERAL_ERROR);
+            return;
+        }
+        UserAuth::UserAuthResultCode onResult = userAuthInstanceV10_->onAuthTip(callback);
+        if (onResult != UserAuth::UserAuthResultCode::SUCCESS) {
+            IAM_LOGE("userAuthInstanceV10_ onAuthTip fail");
+            UserAuth::UserAuthAniHelper::ThrowBusinessError(onResult);
+            return;
+        }
+    }
+
+    void offAuthTip(optional_view<callback<void(AuthTipInfo const&)>> callback) {
+        if (userAuthInstanceV10_ == nullptr) {
+            IAM_LOGE("userAuthInstanceV10_ is null");
+            UserAuth::UserAuthAniHelper::ThrowBusinessError(UserAuth::UserAuthResultCode::GENERAL_ERROR);
+            return;
+        }
+        UserAuth::UserAuthResultCode offResult = userAuthInstanceV10_->offAuthTip(callback);
+        if (offResult != UserAuth::UserAuthResultCode::SUCCESS) {
+            IAM_LOGE("userAuthInstanceV10_ offAuthTip fail");
+            UserAuth::UserAuthAniHelper::ThrowBusinessError(offResult);
+            return;
+        }
+    }
+
 private:
     std::shared_ptr<UserAuth::UserAuthInstanceV10> userAuthInstanceV10_ = nullptr;
 };
@@ -148,14 +176,14 @@ public:
         }
     }
 
-    void on(string_view type, IAuthWidgetCallback const &callback)
+    void onCommand(IAuthWidgetCallback const &callback)
     {
         if (userAuthWidgetMgr_ == nullptr) {
             IAM_LOGE("userAuthWidgetMgr_ is null after MakeShared");
             UserAuth::UserAuthAniHelper::ThrowBusinessError(UserAuth::UserAuthResultCode::GENERAL_ERROR);
             return;
         }
-        UserAuth::UserAuthResultCode onResult = userAuthWidgetMgr_->On(type.c_str(), callback);
+        UserAuth::UserAuthResultCode onResult = userAuthWidgetMgr_->OnCommand(callback);
         if (onResult != UserAuth::UserAuthResultCode::SUCCESS) {
             IAM_LOGE("userAuthWidgetMgr_ on fail");
             UserAuth::UserAuthAniHelper::ThrowBusinessError(onResult);
@@ -163,14 +191,14 @@ public:
         }
     }
 
-    void off(string_view type, optional_view<IAuthWidgetCallback> callback)
+    void offCommand(optional_view<IAuthWidgetCallback> callback)
     {
         if (userAuthWidgetMgr_ == nullptr) {
             IAM_LOGE("userAuthWidgetMgr_ is null after MakeShared");
             UserAuth::UserAuthAniHelper::ThrowBusinessError(UserAuth::UserAuthResultCode::GENERAL_ERROR);
             return;
         }
-        UserAuth::UserAuthResultCode offResult = userAuthWidgetMgr_->Off(type.c_str(), callback);
+        UserAuth::UserAuthResultCode offResult = userAuthWidgetMgr_->OffCommand(callback);
         if (offResult != UserAuth::UserAuthResultCode::SUCCESS) {
             IAM_LOGE("userAuthWidgetMgr_ off fail");
             UserAuth::UserAuthAniHelper::ThrowBusinessError(offResult);
diff --git a/frameworks/ets/ani/user_auth/src/user_auth_ani_helper.cpp b/frameworks/ets/ani/user_auth/src/user_auth_ani_helper.cpp
index d71d585f808267c2cd5c492ff77e533fdb0e91b4..804afab599d19660a379c34e07176ecb54d2f2fe 100644
--- a/frameworks/ets/ani/user_auth/src/user_auth_ani_helper.cpp
+++ b/frameworks/ets/ani/user_auth/src/user_auth_ani_helper.cpp
@@ -22,6 +22,7 @@
 
 #include "taihe/runtime.hpp"
 #include "iam_logger.h"
+#include "auth_common.h"
 
 #define LOG_TAG "USER_AUTH_ANI"
 
@@ -56,6 +57,36 @@ bool UserAuthAniHelper::ConvertUserAuthType(int32_t userAuthType, userAuth::User
     }
 }
 
+bool UserAuthAniHelper::ConvertUserAuthTipCode(int32_t userAuthTipCode, userAuth::UserAuthTipCode &userAuthTipCodeOut)
+{
+    switch (userAuthTipCode) {
+        case UserAuthTipCode::TIP_CODE_FAIL:
+            userAuthTipCodeOut = userAuth::UserAuthTipCode::key_t::COMPARE_FAILURE;
+            return true;
+        case UserAuthTipCode::TIP_CODE_TIMEOUT:
+            userAuthTipCodeOut = userAuth::UserAuthTipCode::key_t::TIMEOUT;
+            return true;
+        case UserAuthTipCode::TIP_CODE_TEMPORARILY_LOCKED:
+            userAuthTipCodeOut = userAuth::UserAuthTipCode::key_t::TEMPORARILY_LOCKED;
+            return true;
+        case UserAuthTipCode::TIP_CODE_PERMANENTLY_LOCKED:
+            userAuthTipCodeOut = userAuth::UserAuthTipCode::key_t::PERMANENTLY_LOCKED;
+            return true;
+        case UserAuthTipCode::TIP_CODE_WIDGET_LOADED:
+            userAuthTipCodeOut = userAuth::UserAuthTipCode::key_t::WIDGET_LOADED;
+            return true;
+        case UserAuthTipCode::TIP_CODE_WIDGET_RELEASED:
+            userAuthTipCodeOut = userAuth::UserAuthTipCode::key_t::WIDGET_RELEASED;
+            return true;
+        case UserAuthTipCode::TIP_CODE_COMPARE_FAIL_WITH_FROZEN:
+            userAuthTipCodeOut = userAuth::UserAuthTipCode::key_t::COMPARE_FAILURE_WITH_FROZEN;
+            return true;
+        default:
+            IAM_LOGE("invalid userAuthTipCode:%{public}d", userAuthTipCode);
+            return false;
+    }
+}
+
 UserAuthResultCode UserAuthAniHelper::ThrowBusinessError(UserAuthResultCode error)
 {
     std::string msgStr;
diff --git a/frameworks/ets/ani/user_auth/src/user_auth_callback_v10.cpp b/frameworks/ets/ani/user_auth/src/user_auth_callback_v10.cpp
index d71d77a2e41da6c98dfe00df22d716b613c11ea0..f2f0ca8d32d6c7a783125465cb833a283ae4b740 100644
--- a/frameworks/ets/ani/user_auth/src/user_auth_callback_v10.cpp
+++ b/frameworks/ets/ani/user_auth/src/user_auth_callback_v10.cpp
@@ -50,6 +50,33 @@ bool UserAuthCallbackV10::HasResultCallback()
     return resultCallback_ != nullptr;
 }
 
+void UserAuthCallbackV10::SetTipCallback(
+    taihe::optional<::taihe::callback<void(userAuth::AuthTipInfo const &)>> tipCallback)
+{
+    std::lock_guard<std::mutex> guard(mutex_);
+    tipCallback_ =
+        Common::MakeShared<taihe::optional<::taihe::callback<void(userAuth::AuthTipInfo const &)>>>(tipCallback);
+}
+
+void UserAuthCallbackV10::ClearTipCallback()
+{
+    std::lock_guard<std::mutex> guard(mutex_);
+    tipCallback_ = nullptr;
+}
+
+std::shared_ptr<taihe::optional<::taihe::callback<void(userAuth::AuthTipInfo const &)>>>
+    UserAuthCallbackV10::GetTipCallback()
+{
+    std::lock_guard<std::mutex> guard(mutex_);
+    return tipCallback_;
+}
+
+bool UserAuthCallbackV10::HasTipCallback()
+{
+    std::lock_guard<std::mutex> guard(mutex_);
+    return tipCallback_ != nullptr;
+}
+
 bool UserAuthCallbackV10::DoResultCallback(
     int32_t result, const std::vector<uint8_t> &token, int32_t authType, EnrolledState enrolledState)
 {
@@ -82,9 +109,43 @@ bool UserAuthCallbackV10::DoResultCallback(
     return true;
 }
 
+bool UserAuthCallbackV10::DoTipInfoCallBack(int32_t tipType, uint32_t tipCode)
+{
+    IAM_LOGI("DoTipInfoCallBack start, authType:%{public}d, tipCode:%{public}u", tipType, tipCode);
+    auto tipCallback = GetTipCallback();
+    if (tipCallback == nullptr) {
+        IAM_LOGE("tipCallback is null");
+        return false;
+    }
+    userAuth::AuthTipInfo authTipInfo = {
+        userAuth::UserAuthType::key_t::PIN, userAuth::UserAuthTipCode::key_t::COMPARE_FAILURE};
+    if (UserAuthHelper::CheckUserAuthType(tipType)) {
+        userAuth::UserAuthType tipTypeAni(userAuth::UserAuthType::key_t::PIN);
+        if (!UserAuthAniHelper::ConvertUserAuthType(tipType, tipTypeAni)) {
+            IAM_LOGE("Set authType error. authType: %{public}d", tipType);
+            return false;
+        }
+        authTipInfo.tipType = tipTypeAni;
+
+        userAuth::UserAuthTipCode tipCodeAni(userAuth::UserAuthTipCode::key_t::COMPARE_FAILURE);
+        if (!UserAuthAniHelper::ConvertUserAuthTipCode(tipCode, tipCodeAni)) {
+            IAM_LOGE("Set tipCode error. tipCode: %{public}d", tipCode);
+            return false;
+        }
+        authTipInfo.tipCode = tipCodeAni;
+        (**tipCallback)(authTipInfo);
+        return true;
+    }
+    return false;
+}
+
 void UserAuthCallbackV10::OnAcquireInfo(
     int32_t module, uint32_t acquireInfo, const UserIam::UserAuth::Attributes &extraInfo)
-{}
+{
+    IAM_LOGI("start, authType:%{public}d, tipCode:%{public}u", module, acquireInfo);
+    bool ret = DoTipInfoCallBack(module, acquireInfo);
+    IAM_LOGD("DoResultCallback ret = %{public}d", ret);
+}
 
 void UserAuthCallbackV10::OnResult(int32_t result, const Attributes &extraInfo)
 {
diff --git a/frameworks/ets/ani/user_auth/src/user_auth_instance_v10.cpp b/frameworks/ets/ani/user_auth/src/user_auth_instance_v10.cpp
index b4492dc5f04051dc53430a080659ff6e50e49111..9e76425018c95226fa88a9986fe637c8097fe70f 100644
--- a/frameworks/ets/ani/user_auth/src/user_auth_instance_v10.cpp
+++ b/frameworks/ets/ani/user_auth/src/user_auth_instance_v10.cpp
@@ -341,48 +341,32 @@ bool UserAuthInstanceV10::CheckUIContext(const std::shared_ptr<AbilityRuntime::C
     return true;
 }
 
-UserAuthResultCode UserAuthInstanceV10::On(std::string type, userAuth::IAuthCallback const &callback)
+UserAuthResultCode UserAuthInstanceV10::OnResult(userAuth::IAuthCallback const &callback)
 {
-    IAM_LOGI("UserAuthInstanceV10 on.");
+    IAM_LOGI("UserAuthInstanceV10 OnResult.");
     if (callback_ == nullptr) {
-        IAM_LOGE("userAuthInstance on callback is null");
+        IAM_LOGE("userAuthInstance OnResult callback is null");
         return UserAuthResultCode::GENERAL_ERROR;
     }
-    static const size_t maxLen = 10;
-    if (type.size() <= 0 || type.size() > maxLen) {
-        IAM_LOGE("getAuthInstance on GetStrValue fail.");
-        return UserAuthResultCode::OHOS_INVALID_PARAM;
-    }
-    if (type == AUTH_EVENT_RESULT) {
-        IAM_LOGI("getAuthInstance on SetResultCallback");
-        callback_->SetResultCallback(callback);
-        return UserAuthResultCode::SUCCESS;
-    } else {
-        IAM_LOGE("getAuthInstance on invalid event:%{public}s", type.c_str());
-        return UserAuthResultCode::OHOS_INVALID_PARAM;
-    }
+    IAM_LOGI("getAuthInstance OnResult SetResultCallback");
+    callback_->SetResultCallback(callback);
+    return UserAuthResultCode::SUCCESS;
 }
 
-UserAuthResultCode UserAuthInstanceV10::Off(std::string type, taihe::optional_view<userAuth::IAuthCallback> callback)
+UserAuthResultCode UserAuthInstanceV10::OffResult(taihe::optional_view<userAuth::IAuthCallback> callback)
 {
-    IAM_LOGI("UserAuthInstanceV10 off.");
+    IAM_LOGI("UserAuthInstanceV10 OffResult.");
     if (callback_ == nullptr) {
-        IAM_LOGE("userAuthInstance off callback is null");
+        IAM_LOGE("userAuthInstance OffResult callback is null");
         return UserAuthResultCode::GENERAL_ERROR;
     }
 
-    if (type == AUTH_EVENT_RESULT) {
-        if (!callback_->HasResultCallback()) {
-            IAM_LOGE("no callback registerred yet");
-            return UserAuthResultCode::GENERAL_ERROR;
-        }
-        callback_->ClearResultCallback();
-        IAM_LOGI("UserAuthResultCode off clear result callback");
-        return UserAuthResultCode::SUCCESS;
-    } else {
-        IAM_LOGE("invalid event:%{public}s", type.c_str());
-        return UserAuthResultCode::OHOS_INVALID_PARAM;
+    if (!callback_->HasResultCallback()) {
+        IAM_LOGE("no callback registerred yet");
+        return UserAuthResultCode::GENERAL_ERROR;
     }
+    callback_->ClearResultCallback();
+    IAM_LOGI("UserAuthResultCode OffResult clear result callback");
     return UserAuthResultCode::SUCCESS;
 }
 
@@ -432,6 +416,36 @@ UserAuthResultCode UserAuthInstanceV10::Cancel()
     reporter.ReportSuccess();
     return UserAuthResultCode::SUCCESS;
 }
+
+UserAuthResultCode UserAuthInstanceV10::onAuthTip(taihe::callback_view<void(userAuth::AuthTipInfo const &)> callback)
+{
+    IAM_LOGI("UserAuthInstanceV10 onAuthTip.");
+    if (callback_ == nullptr) {
+        IAM_LOGE("userAuthInstance onAuthTip callback is null");
+        return UserAuthResultCode::GENERAL_ERROR;
+    }
+    IAM_LOGI("getAuthInstance onAuthTip SetTipCallback");
+    callback_->SetTipCallback(
+        taihe::optional<::taihe::callback<void(userAuth::AuthTipInfo const &)>>{std::in_place_t{}, callback});
+    return UserAuthResultCode::SUCCESS;
+}
+UserAuthResultCode UserAuthInstanceV10::offAuthTip(
+    taihe::optional_view<taihe::callback<void(userAuth::AuthTipInfo const &)>> callback)
+{
+    IAM_LOGI("UserAuthInstanceV10 offAuthTip.");
+    if (callback_ == nullptr) {
+        IAM_LOGE("userAuthInstance offAuthTip callback is null");
+        return UserAuthResultCode::GENERAL_ERROR;
+    }
+
+    if (!callback_->HasTipCallback()) {
+        IAM_LOGE("no callback registerred yet");
+        return UserAuthResultCode::GENERAL_ERROR;
+    }
+    callback_->ClearTipCallback();
+    IAM_LOGI("UserAuthResultCode offAuthTip clear tip callback");
+    return UserAuthResultCode::SUCCESS;
+}
 }  // namespace UserAuth
 }  // namespace UserIam
 }  // namespace OHOS
diff --git a/frameworks/ets/ani/user_auth/src/user_auth_widget_mgr_v10.cpp b/frameworks/ets/ani/user_auth/src/user_auth_widget_mgr_v10.cpp
index 77df3ea34a9ddfad020f3a9c0db10a316bc709b7..5cabb18962d5048f4798932896dfbba9ed8f916d 100644
--- a/frameworks/ets/ani/user_auth/src/user_auth_widget_mgr_v10.cpp
+++ b/frameworks/ets/ani/user_auth/src/user_auth_widget_mgr_v10.cpp
@@ -54,47 +54,36 @@ UserAuthResultCode UserAuthWidgetMgr::Init(int32_t version)
     return static_cast<UserAuthResultCode>(UserAuthHelper::GetResultCodeV10(result));
 }
 
-UserAuthResultCode UserAuthWidgetMgr::On(std::string type, userAuth::IAuthWidgetCallback const &callback)
+UserAuthResultCode UserAuthWidgetMgr::OnCommand(userAuth::IAuthWidgetCallback const &callback)
 {
     IAM_LOGI("UserAuthWidgetMgr on");
     if (callback_ == nullptr) {
         IAM_LOGE("callback is null");
         return UserAuthResultCode::GENERAL_ERROR;
     }
-    if (type == TYPE_COMMAND) {
-        IAM_LOGI("SetCommandCallback");
-        if (callback_->HasCommandCallback()) {
-            IAM_LOGE("command callback has been registerred");
-            return UserAuthResultCode::GENERAL_ERROR;
-        }
-        callback_->SetCommandCallback(callback);
-        return UserAuthResultCode::SUCCESS;
-    } else {
-        IAM_LOGE("invalid event:%{public}s", type.c_str());
-        return UserAuthResultCode::OHOS_INVALID_PARAM;
+    IAM_LOGI("SetCommandCallback");
+    if (callback_->HasCommandCallback()) {
+        IAM_LOGE("command callback has been registerred");
+        return UserAuthResultCode::GENERAL_ERROR;
     }
+    callback_->SetCommandCallback(callback);
+    return UserAuthResultCode::SUCCESS;
 }
 
-UserAuthResultCode UserAuthWidgetMgr::Off(
-    std::string type, taihe::optional_view<userAuth::IAuthWidgetCallback> callback)
+UserAuthResultCode UserAuthWidgetMgr::OffCommand(taihe::optional_view<userAuth::IAuthWidgetCallback> callback)
 {
     IAM_LOGI("UserAuthWidgetMgr off");
     if (callback_ == nullptr) {
         IAM_LOGE("callback is null");
         return UserAuthResultCode::GENERAL_ERROR;
     }
-    if (type == TYPE_COMMAND) {
-        IAM_LOGI("ClearCommandCallback");
-        if (callback_->HasCommandCallback()) {
-            IAM_LOGE("no command callback register yet");
-            return UserAuthResultCode::GENERAL_ERROR;
-        }
-        callback_->ClearCommandCallback();
-        return UserAuthResultCode::SUCCESS;
-    } else {
-        IAM_LOGE("invalid event:%{public}s", type.c_str());
-        return UserAuthResultCode::OHOS_INVALID_PARAM;
+    if (callback_->HasCommandCallback()) {
+        IAM_LOGE("no command callback register yet");
+        return UserAuthResultCode::GENERAL_ERROR;
     }
+    IAM_LOGI("ClearCommandCallback");
+    callback_->ClearCommandCallback();
+    return UserAuthResultCode::SUCCESS;
 }
 }  // namespace UserAuth
 }  // namespace UserIam