diff --git a/frameworks/js/napi/inputmethodclient/js_get_input_method_controller.cpp b/frameworks/js/napi/inputmethodclient/js_get_input_method_controller.cpp
index 332c181640ba963f449e938e02d9503854dcffe7..164fd0a3f091740a7ac5df9820b7d006c4d26519 100644
--- a/frameworks/js/napi/inputmethodclient/js_get_input_method_controller.cpp
+++ b/frameworks/js/napi/inputmethodclient/js_get_input_method_controller.cpp
@@ -64,6 +64,7 @@ napi_value JsGetInputMethodController::Init(napi_env env, napi_value info)
         DECLARE_NAPI_STATIC_PROPERTY("TextInputType", GetJsTextInputTypeProperty(env)),
         DECLARE_NAPI_STATIC_PROPERTY("Direction", GetJsDirectionProperty(env)),
         DECLARE_NAPI_STATIC_PROPERTY("ExtendAction", GetJsExtendActionProperty(env)),
+        DECLARE_NAPI_STATIC_PROPERTY("EnabledState", GetJsEnabledStateProperty(env)),
     };
     NAPI_CALL(
         env, napi_define_properties(env, info, sizeof(descriptor) / sizeof(napi_property_descriptor), descriptor));
@@ -218,6 +219,22 @@ napi_value JsGetInputMethodController::GetJsExtendActionProperty(napi_env env)
     return action;
 }
 
+napi_value JsGetInputMethodController::GetJsEnabledStateProperty(napi_env env)
+{
+    napi_value status = nullptr;
+    napi_value disabled = nullptr;
+    napi_value basicMode = nullptr;
+    napi_value fullExperience = nullptr;
+    NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(EnabledStatus::DISABLED), &disabled));
+    NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(EnabledStatus::BASIC_MODE), &basicMode));
+    NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(EnabledStatus::FULL_EXPERIENCE_MODE), &fullExperience));
+    NAPI_CALL(env, napi_create_object(env, &status));
+    NAPI_CALL(env, napi_set_named_property(env, status, "DISABLED", disabled));
+    NAPI_CALL(env, napi_set_named_property(env, status, "BASIC_MODE", basicMode));
+    NAPI_CALL(env, napi_set_named_property(env, status, "FULL_EXPERIENCE_MODE", fullExperience));
+    return status;
+}
+
 napi_value JsGetInputMethodController::JsConstructor(napi_env env, napi_callback_info cbinfo)
 {
     {
diff --git a/frameworks/js/napi/inputmethodclient/js_get_input_method_controller.h b/frameworks/js/napi/inputmethodclient/js_get_input_method_controller.h
index d0b5039d4d62bf027ef9e798f7376e284e9651cb..86d4e36578e507cc0ade99fe1f6aa20972d6384d 100644
--- a/frameworks/js/napi/inputmethodclient/js_get_input_method_controller.h
+++ b/frameworks/js/napi/inputmethodclient/js_get_input_method_controller.h
@@ -204,6 +204,7 @@ private:
     static napi_value GetJsTextInputTypeProperty(napi_env env);
     static napi_value GetJsDirectionProperty(napi_env env);
     static napi_value GetJsExtendActionProperty(napi_env env);
+    static napi_value GetJsEnabledStateProperty(napi_env env);
     static std::shared_ptr<AppExecFwk::EventHandler> GetEventHandler();
     static const std::set<std::string> TEXT_EVENT_TYPE;
     static constexpr int32_t MAX_TIMEOUT = 2500;
diff --git a/frameworks/js/napi/inputmethodclient/js_get_input_method_setting.cpp b/frameworks/js/napi/inputmethodclient/js_get_input_method_setting.cpp
index 2107e8007b3631eba406bf86bbeee5f346ebd32e..f2e9766b38959be8d3e15a83671e2bf4ed286d88 100644
--- a/frameworks/js/napi/inputmethodclient/js_get_input_method_setting.cpp
+++ b/frameworks/js/napi/inputmethodclient/js_get_input_method_setting.cpp
@@ -66,6 +66,7 @@ napi_value JsGetInputMethodSetting::Init(napi_env env, napi_value exports)
         DECLARE_NAPI_FUNCTION("displayOptionalInputMethod", DisplayOptionalInputMethod),
         DECLARE_NAPI_FUNCTION("showOptionalInputMethods", ShowOptionalInputMethods),
         DECLARE_NAPI_FUNCTION("isPanelShown", IsPanelShown),
+        DECLARE_NAPI_FUNCTION("getInputMethodState", GetInputMethodState),
         DECLARE_NAPI_FUNCTION("on", Subscribe),
         DECLARE_NAPI_FUNCTION("off", UnSubscribe),
     };
@@ -726,5 +727,28 @@ std::shared_ptr<JsGetInputMethodSetting::UvEntry> JsGetInputMethodSetting::GetEn
     }
     return entry;
 }
+
+napi_value JsGetInputMethodSetting::GetInputMethodState(napi_env env, napi_callback_info info)
+{
+    auto ctxt = std::make_shared<GetInputMethodStateContext>();
+    auto output = [ctxt](napi_env env, napi_value *result) -> napi_status {
+        int32_t enableStatus = static_cast<int32_t>(ctxt->enableStatus);
+        *result = JsUtil::GetValue(env, enableStatus);
+        return napi_ok;
+    };
+    auto exec = [ctxt](AsyncCall::Context *ctx) {
+        int32_t errCode = InputMethodController::GetInstance()->GetInputMethodState(ctxt->enableStatus);
+        if (errCode == ErrorCode::NO_ERROR) {
+            ctxt->status = napi_ok;
+            ctxt->SetState(ctxt->status);
+            return;
+        }
+        ctxt->SetErrorCode(errCode);
+    };
+    ctxt->SetAction(nullptr, std::move(output));
+    // 0 means JsAPI:GetInputMethodState has no param.
+    AsyncCall asyncCall(env, info, ctxt, 0);
+    return asyncCall.Call(env, exec, "GetInputMethodState");
+}
 } // namespace MiscServices
 } // namespace OHOS
\ No newline at end of file
diff --git a/frameworks/js/napi/inputmethodclient/js_get_input_method_setting.h b/frameworks/js/napi/inputmethodclient/js_get_input_method_setting.h
index 0651c33fd8e740fd6ba539f45e30b80a3f479845..fb1250ba1aec0ec2aa8b42685f426a25933d82d6 100644
--- a/frameworks/js/napi/inputmethodclient/js_get_input_method_setting.h
+++ b/frameworks/js/napi/inputmethodclient/js_get_input_method_setting.h
@@ -94,6 +94,22 @@ struct GetInputMethodControllerContext : public AsyncCall::Context {
     }
 };
 
+struct GetInputMethodStateContext : public AsyncCall::Context {
+    napi_status status = napi_generic_failure;
+    EnabledStatus enableStatus = EnabledStatus::DISABLED;
+    GetInputMethodStateContext() : Context(nullptr, nullptr){};
+    GetInputMethodStateContext(InputAction input, OutputAction output)
+        : Context(std::move(input), std::move(output)){};
+    napi_status operator()(napi_env env, napi_value *result) override
+    {
+        if (status != napi_ok) {
+            output_ = nullptr;
+            return status;
+        }
+        return Context::operator()(env, result);
+    }
+};
+
 class JsGetInputMethodSetting : public ImeEventListener {
 public:
     JsGetInputMethodSetting() = default;
@@ -111,6 +127,7 @@ public:
     static napi_value DisplayOptionalInputMethod(napi_env env, napi_callback_info info);
     static napi_value ShowOptionalInputMethods(napi_env env, napi_callback_info info);
     static napi_value IsPanelShown(napi_env env, napi_callback_info info);
+    static napi_value GetInputMethodState(napi_env env, napi_callback_info info);
     static napi_value Subscribe(napi_env env, napi_callback_info info);
     static napi_value UnSubscribe(napi_env env, napi_callback_info info);
     static std::shared_ptr<JsGetInputMethodSetting> GetInputMethodSettingInstance();
diff --git a/frameworks/native/inputmethod_controller/include/input_method_status.h b/frameworks/native/inputmethod_controller/include/input_method_status.h
index 8eaf974e1b802be8dcdfa317b536471584370527..bcc3ac8705b46ff7d2fbc45a9881bb5aa3c389c6 100644
--- a/frameworks/native/inputmethod_controller/include/input_method_status.h
+++ b/frameworks/native/inputmethod_controller/include/input_method_status.h
@@ -20,5 +20,10 @@
 
 namespace OHOS ::MiscServices {
 enum InputMethodStatus : uint32_t { DISABLE = 0, ENABLE, ALL };
-}
+enum class EnabledStatus : int32_t {
+    DISABLED = 0,
+    BASIC_MODE,
+    FULL_EXPERIENCE_MODE,
+};
+} // namespace OHOS::MiscServices
 #endif // namespace OHOS::INPUTMETHOD_IMF_INPUT_METHOD_STATUS_H
diff --git a/frameworks/native/inputmethod_controller/include/input_method_system_ability_proxy.h b/frameworks/native/inputmethod_controller/include/input_method_system_ability_proxy.h
index aa76b2683a1645b587600f13d2c2da21254b7135..0405e1e53f8e69ab53e8693c545e774d0f632066 100644
--- a/frameworks/native/inputmethod_controller/include/input_method_system_ability_proxy.h
+++ b/frameworks/native/inputmethod_controller/include/input_method_system_ability_proxy.h
@@ -79,6 +79,7 @@ public:
     // Deprecated because of no permission check, kept for compatibility
     int32_t HideCurrentInputDeprecated() override;
     int32_t ShowCurrentInputDeprecated() override;
+    int32_t GetInputMethodState(EnabledStatus &status) override;
 
 private:
     static inline BrokerDelegator<InputMethodSystemAbilityProxy> delegator_;
diff --git a/frameworks/native/inputmethod_controller/src/input_method_controller.cpp b/frameworks/native/inputmethod_controller/src/input_method_controller.cpp
index 0551cb84dff4e1443dffe320f1f1a7e1096aa7cd..2e58860a0af074ad4eaa9b854340315c2346d07c 100644
--- a/frameworks/native/inputmethod_controller/src/input_method_controller.cpp
+++ b/frameworks/native/inputmethod_controller/src/input_method_controller.cpp
@@ -1396,5 +1396,15 @@ int32_t InputMethodController::FinishTextPreview()
     }
     return ErrorCode::NO_ERROR;
 }
+
+int32_t InputMethodController::GetInputMethodState(EnabledStatus &state)
+{
+    auto proxy = GetSystemAbilityProxy();
+    if (proxy == nullptr) {
+        IMSA_HILOGE("proxy is nullptr!");
+        return ErrorCode::ERROR_NULL_POINTER;
+    }
+    return proxy->GetInputMethodState(state);
+}
 } // namespace MiscServices
 } // namespace OHOS
\ No newline at end of file
diff --git a/frameworks/native/inputmethod_controller/src/input_method_system_ability_proxy.cpp b/frameworks/native/inputmethod_controller/src/input_method_system_ability_proxy.cpp
index d4ca3d9aecc7d6167f09456018d09675d1be00ae..36c3f31b7c479ba74cd4bf1222822d83f6115165 100644
--- a/frameworks/native/inputmethod_controller/src/input_method_system_ability_proxy.cpp
+++ b/frameworks/native/inputmethod_controller/src/input_method_system_ability_proxy.cpp
@@ -279,6 +279,18 @@ int32_t InputMethodSystemAbilityProxy::IsDefaultIme()
     return SendRequest(static_cast<uint32_t>(InputMethodInterfaceCode::IS_DEFAULT_IME));
 }
 
+int32_t InputMethodSystemAbilityProxy::GetInputMethodState(EnabledStatus &status)
+{
+    int32_t statusTmp = 0;
+    auto ret = SendRequest(static_cast<uint32_t>(InputMethodInterfaceCode::GET_IME_STATE), nullptr,
+        [&statusTmp](MessageParcel &reply) { return ITypesUtil::Unmarshal(reply, statusTmp); });
+    if (ret != ErrorCode::NO_ERROR) {
+        return ret;
+    }
+    status = static_cast<EnabledStatus>(statusTmp);
+    return ErrorCode::NO_ERROR;
+}
+
 void InputMethodSystemAbilityProxy::GetMessageOption(int32_t code, MessageOption &option)
 {
     switch (code) {
diff --git a/interfaces/inner_api/inputmethod_controller/include/input_method_controller.h b/interfaces/inner_api/inputmethod_controller/include/input_method_controller.h
index c4690e3eae01f926e4a09b81d2bf3073d7ae1def..36f2c5957836f1d9d4c484bcc27754ea00b5d754 100644
--- a/interfaces/inner_api/inputmethod_controller/include/input_method_controller.h
+++ b/interfaces/inner_api/inputmethod_controller/include/input_method_controller.h
@@ -802,6 +802,17 @@ public:
      */
     IMF_API void Reset();
 
+    /**
+     * @brief Get ime state.
+     *
+     * This function is used to get it's enabled state by ime.
+     *
+     * @param status Indicates the enabled state
+     * @return Returns 0 for success, others for failure.
+     * @since 16
+     */
+    IMF_API int32_t GetInputMethodState(EnabledStatus &status);
+
 private:
     InputMethodController();
     ~InputMethodController();
diff --git a/services/adapter/settings_data_provider/include/enable_ime_data_parser.h b/services/adapter/settings_data_provider/include/enable_ime_data_parser.h
index 42f858811594ed474e83ffc1a3496fa54181e296..e54dc3bbc421ac4b85df8842c92f5f196ec02d52 100644
--- a/services/adapter/settings_data_provider/include/enable_ime_data_parser.h
+++ b/services/adapter/settings_data_provider/include/enable_ime_data_parser.h
@@ -26,6 +26,7 @@
 #include "datashare_helper.h"
 #include "global.h"
 #include "input_method_property.h"
+#include "input_method_status.h"
 #include "serializable.h"
 #include "settings_data_utils.h"
 
@@ -80,7 +81,8 @@ public:
     bool CheckNeedSwitch(const SwitchInfo &info, const int32_t userId);
     void OnUserChanged(const int32_t userId);
     void OnConfigChanged(int32_t userId, const std::string &key);
-
+    int32_t GetImeEnablePattern(int32_t userId, const std::string &bundleName, EnabledStatus &status);
+    
     static constexpr const char *ENABLE_IME = "settings.inputmethod.enable_ime";
     static constexpr const char *ENABLE_KEYBOARD = "settings.inputmethod.enable_keyboard";
     static constexpr const char *TEMP_IME = "settings.inputmethod.temp_ime";
diff --git a/services/adapter/settings_data_provider/include/security_mode_parser.h b/services/adapter/settings_data_provider/include/security_mode_parser.h
index cde08dc3404127045407e7f5cc5a65bd66345bac..634ef81613831b87eccb9ef735b8a4fb70fefb99 100644
--- a/services/adapter/settings_data_provider/include/security_mode_parser.h
+++ b/services/adapter/settings_data_provider/include/security_mode_parser.h
@@ -46,6 +46,7 @@ public:
     SecurityMode GetSecurityMode(const std::string &bundleName, int32_t userId);
     int32_t UpdateFullModeList(int32_t userId);
     bool IsDefaultFullMode(const std::string &bundleName, int32_t userId);
+    bool IsSecurityMode(int32_t userId, const std::string &bundleName);
     static constexpr const char *SECURITY_MODE = "settings.inputmethod.full_experience";
 
 private:
diff --git a/services/adapter/settings_data_provider/src/enable_ime_data_parser.cpp b/services/adapter/settings_data_provider/src/enable_ime_data_parser.cpp
index 9bf780935152c7030a7d159a2365cb5a82823200..31bc0deb8a86f662e6f0a334213fe1e99cf90c98 100644
--- a/services/adapter/settings_data_provider/src/enable_ime_data_parser.cpp
+++ b/services/adapter/settings_data_provider/src/enable_ime_data_parser.cpp
@@ -345,6 +345,28 @@ void EnableImeDataParser::OnConfigChanged(int32_t userId, const std::string &key
     UpdateEnableData(userId, key);
 }
 
+int32_t EnableImeDataParser::GetImeEnablePattern(int32_t userId, const std::string &bundleName, EnabledStatus &status)
+{
+    if (ImeInfoInquirer::GetInstance().GetDefaultIme().bundleName == bundleName) {
+        status = EnabledStatus::BASIC_MODE;
+        return ErrorCode::NO_ERROR;
+    }
+    std::vector<std::string> bundleNames;
+    auto ret = GetEnableIme(userId, bundleNames);
+    if (ret != ErrorCode::NO_ERROR) {
+        IMSA_HILOGE("[%{public}d, %{public}s] GetEnableIme failed:%{public}d.", userId, bundleName.c_str(), ret);
+        return ErrorCode::ERROR_ENABLE_IME;
+    }
+    auto it = std::find_if(bundleNames.begin(), bundleNames.end(),
+        [&bundleName](const std::string &bundleNameTmp) { return bundleNameTmp == bundleName; });
+    if (it == bundleNames.end()) {
+        status = EnabledStatus::DISABLED;
+        return ErrorCode::NO_ERROR;
+    }
+    status = EnabledStatus::BASIC_MODE;
+    return ErrorCode::NO_ERROR;
+}
+
 int32_t EnableImeDataParser::UpdateEnableData(int32_t userId, const std::string &key)
 {
     std::lock_guard<std::mutex> autoLock(listMutex_);
diff --git a/services/adapter/settings_data_provider/src/security_mode_parser.cpp b/services/adapter/settings_data_provider/src/security_mode_parser.cpp
index 0b09d12fdbc6cfa8a2bc79fe15c4971b5ff16b42..e387ef66a43ebe9b59ddf42cc0dfb96fb55342f4 100644
--- a/services/adapter/settings_data_provider/src/security_mode_parser.cpp
+++ b/services/adapter/settings_data_provider/src/security_mode_parser.cpp
@@ -152,6 +152,12 @@ bool SecurityModeParser::IsDefaultFullMode(const std::string &bundleName, int32_
     return isDefaultFull;
 }
 
+bool SecurityModeParser::IsSecurityMode(int32_t userId, const std::string &bundleName)
+{
+    SecurityMode mode = GetSecurityMode(bundleName, userId);
+    return mode == SecurityMode::FULL;
+}
+
 bool SecurityModeParser::IsExpired(const std::string &expirationTime)
 {
     std::istringstream expirationTimeStr(expirationTime);
diff --git a/services/include/i_input_method_system_ability.h b/services/include/i_input_method_system_ability.h
index 86c5c5158422e77c9992d89eaa50a5bce6aa8818..d18e96f2cc7eb5f02f0bd43d8ce941e32541658f 100644
--- a/services/include/i_input_method_system_ability.h
+++ b/services/include/i_input_method_system_ability.h
@@ -76,6 +76,7 @@ public:
     virtual int32_t GetSecurityMode(int32_t &security) = 0;
     virtual int32_t IsDefaultIme() = 0;
     virtual int32_t ConnectSystemCmd(const sptr<IRemoteObject> &channel, sptr<IRemoteObject> &agent) = 0;
+    virtual int32_t GetInputMethodState(EnabledStatus &status) = 0;
 
     // Deprecated because of no permission check, and keep for compatibility
     virtual int32_t HideCurrentInputDeprecated() = 0;
diff --git a/services/include/input_method_system_ability.h b/services/include/input_method_system_ability.h
index b68460c7898da333798fd23b2babe7ee5995f35d..e92b5b1ac80b10de3655a15895caa3eafd7246a3 100644
--- a/services/include/input_method_system_ability.h
+++ b/services/include/input_method_system_ability.h
@@ -90,7 +90,8 @@ public:
     int Dump(int fd, const std::vector<std::u16string> &args) override;
     void DumpAllMethod(int fd);
     int32_t IsDefaultIme() override;
-
+    int32_t GetInputMethodState(EnabledStatus &status) override;
+        
 protected:
     void OnStart() override;
     void OnStop() override;
@@ -167,7 +168,10 @@ private:
     int32_t StartInputType(int32_t userId, InputType type);
     // if switch input type need to switch ime, then no need to hide panel first.
     void NeedHideWhenSwitchInputType(int32_t userId, bool &needHide);
-
+    int32_t GetInputMethodState(int32_t userId, const std::string &bundleName, EnabledStatus &status);
+    bool IsSecurityMode(int32_t userId, const std::string &bundleName);
+    int32_t GetImeEnablePattern(int32_t userId, const std::string &bundleName, EnabledStatus &status);
+    
     std::mutex checkMutex_;
     void DatashareCallback(const std::string &key);
     std::atomic<bool> enableImeOn_ = false;
diff --git a/services/include/input_method_system_ability_stub.h b/services/include/input_method_system_ability_stub.h
index 2ed222cde61cc779a0f85ed8b53819278aca1c5e..6997ae43fb4967f33ba938bfe3f95895609bee64 100644
--- a/services/include/input_method_system_ability_stub.h
+++ b/services/include/input_method_system_ability_stub.h
@@ -105,6 +105,8 @@ private:
 
     int32_t InitConnectOnRemote(MessageParcel &data, MessageParcel &reply);
 
+    int32_t GetInputMethodStateOnRemote(MessageParcel &data, MessageParcel &reply);
+
     using RequestHandler = int32_t (InputMethodSystemAbilityStub::*)(MessageParcel &, MessageParcel &);
     static inline constexpr RequestHandler HANDLERS[static_cast<uint32_t>(InputMethodInterfaceCode::IMS_CMD_END)] = {
         &InputMethodSystemAbilityStub::InvalidRequest,
@@ -176,6 +178,8 @@ private:
             &InputMethodSystemAbilityStub::IsCurrentImeByPidOnRemote,
         [static_cast<uint32_t>(InputMethodInterfaceCode::INIT_CONNECT)] =
             &InputMethodSystemAbilityStub::InitConnectOnRemote,
+        [static_cast<uint32_t>(InputMethodInterfaceCode::GET_IME_STATE)] =
+            &InputMethodSystemAbilityStub::GetInputMethodStateOnRemote,
     };
 };
 } // namespace OHOS::MiscServices
diff --git a/services/include/inputmethod_service_ipc_interface_code.h b/services/include/inputmethod_service_ipc_interface_code.h
index 959b6ed77f76279e51727afcdba1da0e952df0fa..5e99611b09443ffdd0693ebd0203e54164cd01ac 100644
--- a/services/include/inputmethod_service_ipc_interface_code.h
+++ b/services/include/inputmethod_service_ipc_interface_code.h
@@ -55,6 +55,8 @@ enum class InputMethodInterfaceCode {
     CONNECT_SYSTEM_CMD,
     IS_CURRENT_IME_BY_PID,
     INIT_CONNECT,
+    GET_IME_STATE,
+    
     IMS_CMD_END,
 };
 } // namespace MiscServices
diff --git a/services/src/input_method_system_ability.cpp b/services/src/input_method_system_ability.cpp
index 8e36cd4c0f518fdbedd149a7237db0214216c416..fd52b3a21f9f6eaee2d939d33850e379817c8e03 100644
--- a/services/src/input_method_system_ability.cpp
+++ b/services/src/input_method_system_ability.cpp
@@ -16,6 +16,7 @@
 #include "input_method_system_ability.h"
 
 #include <unistd.h>
+#include <algorithm>
 
 #include "ability_connect_callback_proxy.h"
 #include "ability_manager_errors.h"
@@ -1816,5 +1817,60 @@ void InputMethodSystemAbility::NeedHideWhenSwitchInputType(int32_t userId, bool
     }
     needHide = currentImeCfg->bundleName == ime.bundleName;
 }
+
+int32_t InputMethodSystemAbility::GetInputMethodState(EnabledStatus &status)
+{
+    auto userId = GetCallingUserId();
+    auto bundleName = FullImeInfoManager::GetInstance().Get(userId, IPCSkeleton::GetCallingTokenID());
+    if (bundleName.empty()) {
+        bundleName = identityChecker_->GetBundleNameByToken(IPCSkeleton::GetCallingTokenID());
+        if (!ImeInfoInquirer::GetInstance().IsInputMethod(userId, bundleName)) {
+            IMSA_HILOGE("[%{public}d, %{public}s] not an ime.", userId, bundleName.c_str());
+            return ErrorCode::ERROR_NOT_IME;
+        }
+    }
+
+    auto ret = GetInputMethodState(userId, bundleName, status);
+    if (ret != ErrorCode::NO_ERROR) {
+        return ret;
+    }
+    return ErrorCode::NO_ERROR;
+}
+
+int32_t InputMethodSystemAbility::GetInputMethodState(
+    int32_t userId, const std::string &bundleName, EnabledStatus &status)
+{
+    auto isDefaultBasicMode = !ImeInfoInquirer::GetInstance().IsEnableInputMethod();
+    auto isDefaultFullExperience = !ImeInfoInquirer::GetInstance().IsEnableSecurityMode();
+    IMSA_HILOGI("sys cfg:[%{public}d, %{public}d].", isDefaultBasicMode, isDefaultFullExperience);
+    auto isSecurityMode = SecurityModeParser::GetInstance()->IsSecurityMode(userId, bundleName);
+    if (isDefaultBasicMode) {
+        if (isDefaultFullExperience) {
+            status = EnabledStatus::FULL_EXPERIENCE_MODE;
+            return ErrorCode::NO_ERROR;
+        }
+        status = isSecurityMode ? EnabledStatus::FULL_EXPERIENCE_MODE : EnabledStatus::BASIC_MODE;
+        return ErrorCode::NO_ERROR;
+    }
+
+    if (isDefaultFullExperience) {
+        auto ret = EnableImeDataParser::GetInstance()->GetImeEnablePattern(userId, bundleName, status);
+        if (ret != ErrorCode::NO_ERROR) {
+            return ret;
+        }
+        if (status == EnabledStatus::BASIC_MODE) {
+            status = EnabledStatus::FULL_EXPERIENCE_MODE;
+        }
+        return ErrorCode::NO_ERROR;
+    }
+
+    if (isSecurityMode) {
+        status = EnabledStatus::FULL_EXPERIENCE_MODE;
+        return ErrorCode::NO_ERROR;
+    }
+
+    auto ret = EnableImeDataParser::GetInstance()->GetImeEnablePattern(userId, bundleName, status);
+    return ret;
+}
 } // namespace MiscServices
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/src/input_method_system_ability_stub.cpp b/services/src/input_method_system_ability_stub.cpp
index dd4e78dd83e33d326e09db13dd250a48fe624972..39385743c5f1122feff02b33f14278e928d449d7 100644
--- a/services/src/input_method_system_ability_stub.cpp
+++ b/services/src/input_method_system_ability_stub.cpp
@@ -412,5 +412,13 @@ int32_t InputMethodSystemAbilityStub::InitConnectOnRemote(MessageParcel &data, M
 {
     return reply.WriteInt32(InitConnect()) ? ErrorCode::NO_ERROR : ErrorCode::ERROR_EX_PARCELABLE;
 }
+
+int32_t InputMethodSystemAbilityStub::GetInputMethodStateOnRemote(MessageParcel &data, MessageParcel &reply)
+{
+    EnabledStatus status = EnabledStatus::DISABLED;
+    int32_t ret = GetInputMethodState(status);
+    return ITypesUtil::Marshal(reply, ret, static_cast<int32_t>(status)) ? ErrorCode::NO_ERROR
+                                                                         : ErrorCode::ERROR_EX_PARCELABLE;
+}
 } // namespace MiscServices
 } // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/cpp_test/mock/ime_info_inquirer.cpp b/test/unittest/cpp_test/mock/ime_info_inquirer.cpp
index 9dc955e17b35fe73ea775927710fc2af3f435911..3e06e13f5c1b963422edaa414b936bbba5951305 100644
--- a/test/unittest/cpp_test/mock/ime_info_inquirer.cpp
+++ b/test/unittest/cpp_test/mock/ime_info_inquirer.cpp
@@ -53,5 +53,11 @@ bool ImeInfoInquirer::GetImeVersionCode(int32_t userId, const std::string &bundl
     versionCode = 0;
     return true;
 }
+
+ImeNativeCfg ImeInfoInquirer::GetDefaultIme()
+{
+    ImeNativeCfg imeCfg;
+    return imeCfg;
+}
 } // namespace MiscServices
 } // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/cpp_test/mock/ime_info_inquirer.h b/test/unittest/cpp_test/mock/ime_info_inquirer.h
index 827098b2ab658d518b3997f527a2c9fb1ce48ad8..51ad2381d445cd25c3e8e8c1f743ada818b785a0 100644
--- a/test/unittest/cpp_test/mock/ime_info_inquirer.h
+++ b/test/unittest/cpp_test/mock/ime_info_inquirer.h
@@ -26,6 +26,13 @@
 
 namespace OHOS {
 namespace MiscServices {
+struct ImeNativeCfg {
+    std::string imeId;
+    std::string bundleName;
+    std::string subName;
+    std::string extName;
+};
+
 class ImeInfoInquirer {
 public:
     static ImeInfoInquirer &GetInstance();
@@ -34,6 +41,7 @@ public:
     std::shared_ptr<Property> GetDefaultImeCfgProp();
     bool GetImeAppId(int32_t userId, const std::string &bundleName, std::string &appId);
     bool GetImeVersionCode(int32_t userId, const std::string &bundleName, uint32_t &versionCode);
+    ImeNativeCfg GetDefaultIme();
 
 private:
     static std::shared_ptr<ImeInfo> defaultIme_;
diff --git a/test/unittest/cpp_test/src/input_method_ability_test.cpp b/test/unittest/cpp_test/src/input_method_ability_test.cpp
index ee355d492aed1ddf21708ae20cf55a62b41802c3..7e0c827bb80ae97d5bf842f41f8162518e371f49 100644
--- a/test/unittest/cpp_test/src/input_method_ability_test.cpp
+++ b/test/unittest/cpp_test/src/input_method_ability_test.cpp
@@ -1304,6 +1304,20 @@ HWTEST_F(InputMethodAbilityTest, testFinishTextPreview_002, TestSize.Level0)
     EXPECT_FALSE(TextListener::isFinishTextPreviewCalled_);
 }
 
+/**
+ *@tc.name: testGetInputMethodState_001
+ *@tc.desc: IMA
+ *@tc.type: FUNC
+ *@tc.require:
+ */
+HWTEST_F(InputMethodAbilityTest, testGetInputMethodState_001, TestSize.Level0)
+{
+    IMSA_HILOGI("InputMethodAbilityTest GetInputMethodState_001 Test START");
+    EnabledStatus status = EnabledStatus::DISABLED;
+    auto ret = InputMethodAbilityTest::imsa_->GetInputMethodState(status);
+    EXPECT_EQ(ret, ErrorCode::ERROR_NOT_IME);
+}
+
 /**
  * @tc.name: testFinishTextPreview_003
  * @tc.desc: IMA
diff --git a/test/unittest/cpp_test/src/input_method_controller_test.cpp b/test/unittest/cpp_test/src/input_method_controller_test.cpp
index adcd48b208a0c4a4200296f6a3c18947f8011d1d..7588678617083fbd13aabcd600064674ebb4720f 100644
--- a/test/unittest/cpp_test/src/input_method_controller_test.cpp
+++ b/test/unittest/cpp_test/src/input_method_controller_test.cpp
@@ -42,17 +42,21 @@
 #include "i_input_method_system_ability.h"
 #include "if_system_ability_manager.h"
 #include "input_client_stub.h"
+
+#include "enable_ime_data_parser.h"
 #include "input_data_channel_stub.h"
 #include "input_death_recipient.h"
 #include "input_method_ability.h"
 #include "input_method_engine_listener_impl.h"
 #include "input_method_system_ability_proxy.h"
 #include "input_method_utils.h"
+#include "ime_info_inquirer.h"
 #include "iservice_registry.h"
 #include "key_event_util.h"
 #include "keyboard_listener.h"
 #include "message_parcel.h"
 #include "scope_utils.h"
+#include "security_mode_parser.h"
 #include "system_ability.h"
 #include "system_ability_definition.h"
 #include "tdd_util.h"
@@ -67,6 +71,7 @@ constexpr uint32_t RETRY_TIMES = 5;
 constexpr uint32_t WAIT_INTERVAL = 500;
 constexpr size_t PRIVATE_COMMAND_SIZE_MAX = 32 * 1024;
 constexpr uint32_t WAIT_SA_DIE_TIME_OUT = 3;
+const std::string IME_KEY = "settings.inputmethod.enable_ime";
 
 class SelectListenerMock : public ControllerListener {
 public:
@@ -1565,6 +1570,102 @@ HWTEST_F(InputMethodControllerTest, testFinishTextPreviewAfterDetach_002, TestSi
     EXPECT_FALSE(TextListener::isFinishTextPreviewCalled_);
 }
 
+/**
+ * @tc.name: testGetInputMethodState_001
+ * @tc.desc: IMA
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(InputMethodControllerTest, testGetInputMethodState_001, TestSize.Level0)
+{
+    IMSA_HILOGI("InputMethodControllerTest GetInputMethodState_001 Test START");
+    EnabledStatus status = EnabledStatus::DISABLED;
+    SecurityModeParser::GetInstance()->fullModeList_.push_back(TddUtil::currentBundleNameMock_);
+    EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back(TddUtil::currentBundleNameMock_);
+    auto ret = inputMethodController_->GetInputMethodState(status);
+    EXPECT_EQ(ret, ErrorCode::NO_ERROR);
+    EXPECT_TRUE(status == EnabledStatus::FULL_EXPERIENCE_MODE);
+    SecurityModeParser::GetInstance()->fullModeList_.clear();
+    EnableImeDataParser::GetInstance()->enableList_.clear();
+}
+
+/**
+ * @tc.name: testGetInputMethodState_002
+ * @tc.desc: IMA
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(InputMethodControllerTest, testGetInputMethodState_002, TestSize.Level0)
+{
+    IMSA_HILOGI("InputMethodControllerTest GetInputMethodState_002 Test START");
+    EnabledStatus status = EnabledStatus::DISABLED;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableFullExperienceFeature = true;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableInputMethodFeature = true;
+    EnableImeDataParser::GetInstance()->enableList_.clear();
+    SecurityModeParser::GetInstance()->fullModeList_.clear();
+    auto ret = inputMethodController_->GetInputMethodState(status);
+    EXPECT_EQ(ret, ErrorCode::NO_ERROR);
+    EXPECT_TRUE(status != EnabledStatus::FULL_EXPERIENCE_MODE);
+    ImeInfoInquirer::GetInstance().systemConfig_.enableFullExperienceFeature = false;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableInputMethodFeature = false;
+}
+
+/**
+ * @tc.name: testGetInputMethodState_003
+ * @tc.desc: IMA
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(InputMethodControllerTest, testGetInputMethodState_003, TestSize.Level0)
+{
+    IMSA_HILOGI("InputMethodControllerTest GetInputMethodState_003 Test START");
+    EnabledStatus status = EnabledStatus::DISABLED;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableFullExperienceFeature = true;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableInputMethodFeature = true;
+    EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back(TddUtil::currentBundleNameMock_);
+    auto ret = inputMethodController_->GetInputMethodState(status);
+    EXPECT_EQ(ret, ErrorCode::NO_ERROR);
+    EXPECT_TRUE(status == EnabledStatus::BASIC_MODE);
+    ImeInfoInquirer::GetInstance().systemConfig_.enableFullExperienceFeature = false;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableInputMethodFeature = false;
+    EnableImeDataParser::GetInstance()->enableList_.clear();
+}
+
+/**
+ * @tc.name: testGetInputMethodState_004
+ * @tc.desc: IMA
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(InputMethodControllerTest, testGetInputMethodState_004, TestSize.Level0)
+{
+    IMSA_HILOGI("InputMethodControllerTest GetInputMethodState_004 Test START");
+    EnabledStatus status = EnabledStatus::DISABLED;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableFullExperienceFeature = true;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableInputMethodFeature = false;
+    auto ret = inputMethodController_->GetInputMethodState(status);
+    EXPECT_EQ(ret, ErrorCode::NO_ERROR);
+    EXPECT_TRUE(status == EnabledStatus::BASIC_MODE);
+    ImeInfoInquirer::GetInstance().systemConfig_.enableFullExperienceFeature = false;
+}
+
+/**
+ * @tc.name: testGetInputMethodState_005
+ * @tc.desc: IMA
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(InputMethodControllerTest, testGetInputMethodState_005, TestSize.Level0)
+{
+    IMSA_HILOGI("InputMethodControllerTest GetInputMethodState_005 Test START");
+    EnabledStatus status = EnabledStatus::DISABLED;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableFullExperienceFeature = false;
+    ImeInfoInquirer::GetInstance().systemConfig_.enableInputMethodFeature = false;
+    auto ret = inputMethodController_->GetInputMethodState(status);
+    EXPECT_EQ(ret, ErrorCode::NO_ERROR);
+    EXPECT_TRUE(status == EnabledStatus::FULL_EXPERIENCE_MODE);
+}
+
 /**
  * @tc.name: testOnInputReady
  * @tc.desc: IMC testOnInputReady