add default full ime

Signed-off-by: zhaolinglan <zhaolinglan1@huawei.com>

etc/init/inputmethodservice.cfg

@@ -14,6 +14,7 @@
             "permission" : [
                 "ohos.permission.INPUT_MONITORING",
                 "ohos.permission.GET_BUNDLE_INFO",
+                "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED",
                 "ohos.permission.REPORT_RESOURCE_SCHEDULE_EVENT",
                 "ohos.permission.CONNECT_INPUT_METHOD_EXTENSION",
                 "ohos.permission.MANAGE_LOCAL_ACCOUNTS",

frameworks/native/inputmethod_controller/include/input_method_property.h

@@ -46,6 +46,7 @@ struct SubProperty {
 struct FullImeInfo {
     bool isNewIme{ false };
     uint32_t tokenId{ 0 };
+    std::string appId;
     Property prop;
     std::vector<SubProperty> subProps;
 };

services/adapter/settings_data_provider/include/security_mode_parser.h

@@ -45,6 +45,7 @@ public:
     int32_t Initialize(const int32_t userId);
     SecurityMode GetSecurityMode(const std::string &bundleName, int32_t userId);
     int32_t UpdateFullModeList(int32_t userId);
+    bool IsDefaultFullMode(const std::string &bundleName, int32_t userId);
     static constexpr const char *SECURITY_MODE = "settings.inputmethod.full_experience";
 
 private:
@@ -53,6 +54,7 @@ private:
 
     bool ParseSecurityMode(const std::string &valueStr, const int32_t userId);
     bool IsFullMode(const std::string bundleName);
+    bool IsExpired(const std::string &expirationTime);
     static std::mutex instanceMutex_;
     static sptr<SecurityModeParser> instance_;
     std::mutex listMutex_;

services/adapter/settings_data_provider/src/security_mode_parser.cpp

@@ -15,11 +15,19 @@
 
 #include "security_mode_parser.h"
 
+#include <algorithm>
+#include <chrono>
+#include <ctime>
+#include <iomanip>
+#include <sstream>
+
+#include "full_ime_info_manager.h"
 #include "ime_info_inquirer.h"
 #include "input_method_utils.h"
 #include "iservice_registry.h"
 #include "serializable.h"
 #include "settings_data_utils.h"
+#include "sys_cfg_parser.h"
 #include "system_ability_definition.h"
 namespace OHOS {
 namespace MiscServices {
@@ -87,11 +95,6 @@ SecurityMode SecurityModeParser::GetSecurityMode(const std::string &bundleName,
     if (bundleName == SYSTEM_SPECIAL_IME) {
         return SecurityMode::FULL;
     }
-    // always set default ime to full mode, remove this rule when default ime finishes adaptation.
-    auto defaultIme = ImeInfoInquirer::GetInstance().GetDefaultImeCfgProp();
-    if (defaultIme != nullptr && bundleName == defaultIme->name) {
-        return SecurityMode::FULL;
-    }
     if (!initialized_) {
         std::lock_guard<std::mutex> lock(initLock_);
         if (!initialized_) {
@@ -113,5 +116,46 @@ bool SecurityModeParser::IsFullMode(std::string bundleName)
         [&bundleName](const std::string &bundle) { return bundle == bundleName; });
     return it != fullModeList_.end();
 }
+
+bool SecurityModeParser::IsDefaultFullMode(const std::string &bundleName, int32_t userId)
+{
+    auto defaultIme = ImeInfoInquirer::GetInstance().GetDefaultImeCfgProp();
+    if (defaultIme != nullptr && bundleName == defaultIme->name) {
+        return true;
+    }
+    std::string appId;
+    if (!ImeInfoInquirer::GetInstance().GetImeAppId(userId, bundleName, appId)) {
+        IMSA_HILOGE("%{public}s failed to get app id", bundleName.c_str());
+        return false;
+    }
+    std::vector<DefaultFullImeInfo> defaultFullImeList;
+    if (!SysCfgParser::ParseDefaultFullIme(defaultFullImeList)) {
+        IMSA_HILOGE("failed to parse config");
+        return false;
+    }
+    auto ime = std::find_if(defaultFullImeList.begin(), defaultFullImeList.end(),
+        [&appId](const auto &ime) { return ime.appId == appId; });
+    if (ime == defaultFullImeList.end()) {
+        IMSA_HILOGD("not default FULL");
+        return false;
+    }
+    bool isDefaultFull = !IsExpired(ime->expirationTime);
+    IMSA_HILOGI("ime: %{public}s, isDefaultFull: %{public}d", bundleName.c_str(), isDefaultFull);
+    return isDefaultFull;
+}
+
+bool SecurityModeParser::IsExpired(const std::string &expirationTime)
+{
+    std::istringstream expirationTimeStr(expirationTime);
+    std::tm expTime = {};
+    expirationTimeStr >> std::get_time(&expTime, "%Y-%m-%d %H:%M:%S");
+    if (expirationTimeStr.fail()) {
+        IMSA_HILOGE("get time error, expirationTime: %{public}s", expirationTime.c_str());
+        return false;
+    }
+    auto expTimePoint = std::chrono::system_clock::from_time_t(std::mktime(&expTime));
+    auto now = std::chrono::system_clock::now();
+    return expTimePoint < now;
+}
 } // namespace MiscServices
 } // namespace OHOS

services/include/full_ime_info_manager.h

@@ -36,6 +36,7 @@ public:
     int32_t Update(int32_t userId, const std::string &bundleName); // package changed
     std::vector<FullImeInfo> Get(int32_t userId);
     std::string Get(int32_t userId, uint32_t tokenId);
+    bool Get(const std::string &bundleName, int32_t userId, FullImeInfo &fullImeInfo);
     bool Has(int32_t userId, const std::string &bundleName);
 
 private:

services/include/ime_info_inquirer.h

@@ -80,6 +80,7 @@ public:
     std::shared_ptr<Property> GetDefaultImeCfgProp();
     std::shared_ptr<SubProperty> FindTargetSubtypeByCondition(const std::vector<SubProperty> &subProps,
         const Condition &condition);
+    bool GetImeAppId(int32_t userId, const std::string &bundleName, std::string &appId);
     int32_t GetDefaultInputMethod(const int32_t userId, std::shared_ptr<Property> &prop, bool isBrief = false);
     int32_t GetInputMethodConfig(const int32_t userId, AppExecFwk::ElementName &inputMethodConfig);
     int32_t ListInputMethod(int32_t userId, InputMethodStatus status, std::vector<Property> &props, bool enableOn);
@@ -103,6 +104,7 @@ private:
     SubProperty GetExtends(const std::vector<OHOS::AppExecFwk::Metadata> &metaData);
     std::string GetStringById(const std::string &bundleName, const std::string &moduleName, const int32_t labelId,
         const int32_t userId);
+    bool GetAppIdByBundleName(int32_t userId, const std::string &bundleName, std::string &appId);
     std::shared_ptr<ImeInfo> GetImeInfoFromCache(const int32_t userId, const std::string &bundleName,
         const std::string &subName);
     std::shared_ptr<ImeInfo> GetImeInfoFromBundleMgr(

services/include/sys_cfg_parser.h

@@ -97,11 +97,31 @@ struct SysPanelAdjustCfg : public Serializable {
     }
 };
 
+struct DefaultFullImeInfo : public Serializable {
+    std::string appId;
+    std::string expirationTime;
+    bool Unmarshal(cJSON *node) override
+    {
+        bool ret = GetValue(node, GET_NAME(appId), appId);
+        ret &= GetValue(node, GET_NAME(expirationTime), expirationTime);
+        return ret;
+    }
+};
+
+struct DefaultFullImeCfg : Serializable {
+    std::vector<DefaultFullImeInfo> defaultFullImeList;
+    bool Unmarshal(cJSON *node) override
+    {
+        return GetValue(node, GET_NAME(defaultFullImeList), defaultFullImeList);
+    }
+};
+
 class SysCfgParser {
 public:
     static bool ParseSystemConfig(SystemConfig &systemConfig);
     static bool ParseInputType(std::vector<InputTypeInfo> &inputType);
     static bool ParsePanelAdjust(std::vector<SysPanelAdjust> &sysPanelAdjust);
+    static bool ParseDefaultFullIme(std::vector<DefaultFullImeInfo> &defaultFullImeList);
 
 private:
     static constexpr const char *SYS_CFG_FILE_PATH = "etc/inputmethod/inputmethod_framework_config.json";

services/src/full_ime_info_manager.cpp

@@ -175,6 +175,24 @@ std::vector<FullImeInfo> FullImeInfoManager::Get(int32_t userId)
     return it->second;
 }
 
+bool FullImeInfoManager::Get(const std::string &bundleName, int32_t userId, FullImeInfo &fullImeInfo)
+{
+    std::lock_guard<std::mutex> lock(lock_);
+    auto it = fullImeInfos_.find(userId);
+    if (it == fullImeInfos_.end()) {
+        IMSA_HILOGD("user %{public}d info", userId);
+        return false;
+    }
+    auto iter = std::find_if(it->second.begin(), it->second.end(),
+        [&bundleName](const FullImeInfo &info) { return bundleName == info.prop.name; });
+    if (iter == it->second.end()) {
+        IMSA_HILOGD("ime: %{public}s not in cache", bundleName.c_str());
+        return false;
+    }
+    fullImeInfo = *iter;
+    return true;
+}
+
 bool FullImeInfoManager::Has(int32_t userId, const std::string &bundleName)
 {
     std::lock_guard<std::mutex> lock(lock_);

services/src/ime_info_inquirer.cpp

@@ -1051,6 +1051,9 @@ int32_t ImeInfoInquirer::GetFullImeInfo(
         GetStringById(extInfos[0].bundleName, extInfos[0].moduleName, extInfos[0].applicationInfo.labelId, userId);
     imeInfo.prop.labelId = extInfos[0].applicationInfo.labelId;
     imeInfo.prop.iconId = extInfos[0].applicationInfo.iconId;
+    if (!GetAppIdByBundleName(userId, imeInfo.prop.name, imeInfo.appId)) {
+        IMSA_HILOGE("%{public}s failed to get app id", imeInfo.prop.name.c_str());
+    }
     return ErrorCode::NO_ERROR;
 }
 
@@ -1100,5 +1103,26 @@ bool ImeInfoInquirer::IsRunningExtension(const std::pair<std::string, std::strin
     IMSA_HILOGW("[%{public}s, %{public}s] is running!", ime.first.c_str(), ime.second.c_str());
     return true;
 }
+
+bool ImeInfoInquirer::GetImeAppId(int32_t userId, const std::string &bundleName, std::string &appId)
+{
+    FullImeInfo imeInfo;
+    if (FullImeInfoManager::GetInstance().Get(bundleName, userId, imeInfo) && !imeInfo.appId.empty()) {
+        appId = imeInfo.appId;
+        return true;
+    }
+    return GetAppIdByBundleName(userId, bundleName, appId);
+}
+
+bool ImeInfoInquirer::GetAppIdByBundleName(int32_t userId, const std::string &bundleName, std::string &appId)
+{
+    auto bundleMgr = GetBundleMgr();
+    if (bundleMgr == nullptr) {
+        IMSA_HILOGE("failed to get bundleMgr");
+        return false;
+    }
+    appId = bundleMgr->GetAppIdByBundleName(bundleName, userId);
+    return !appId.empty();
+}
 } // namespace MiscServices
 } // namespace OHOS

services/src/peruser_session.cpp

@@ -1011,7 +1011,11 @@ bool PerUserSession::GetCurrentUsingImeId(ImeIdentification &imeId)
 AAFwk::Want PerUserSession::GetWant(const std::shared_ptr<ImeNativeCfg> &ime)
 {
     SecurityMode mode;
-    if (ImeInfoInquirer::GetInstance().IsEnableSecurityMode()) {
+    bool isolatedSandBox = true;
+    if (SecurityModeParser::GetInstance()->IsDefaultFullMode(ime->bundleName, userId_)) {
+        mode = SecurityMode::FULL;
+        isolatedSandBox = false;
+    } else if (ImeInfoInquirer::GetInstance().IsEnableSecurityMode()) {
         mode = SecurityModeParser::GetInstance()->GetSecurityMode(ime->bundleName, userId_);
     } else {
         mode = SecurityMode::FULL;
@@ -1019,8 +1023,6 @@ AAFwk::Want PerUserSession::GetWant(const std::shared_ptr<ImeNativeCfg> &ime)
     AAFwk::Want want;
     want.SetElementName(ime->bundleName, ime->extName);
     want.SetParam(STRICT_MODE, !(mode == SecurityMode::FULL));
-    auto defaultIme = ImeInfoInquirer::GetInstance().GetDefaultImeCfgProp();
-    auto isolatedSandBox = (defaultIme != nullptr && defaultIme->name != ime->bundleName);
     want.SetParam(ISOLATED_SANDBOX, isolatedSandBox);
     IMSA_HILOGI("userId: %{public}d, ime: %{public}s, mode: %{public}d, isolatedSandbox: %{public}d", userId_,
         ime->imeId.c_str(), static_cast<int32_t>(mode), isolatedSandBox);

services/src/sys_cfg_parser.cpp

@@ -60,6 +60,19 @@ bool SysCfgParser::ParsePanelAdjust(std::vector<SysPanelAdjust> &sysPanelAdjust)
     return ret;
 }
 
+bool SysCfgParser::ParseDefaultFullIme(std::vector<DefaultFullImeInfo> &defaultFullImeList)
+{
+    auto content = GetSysCfgContent(GET_NAME(defaultFullImeList));
+    if (content.empty()) {
+        IMSA_HILOGD("content is empty");
+        return false;
+    }
+    DefaultFullImeCfg defaultFullImeCfg;
+    auto ret = defaultFullImeCfg.Unmarshall(content);
+    defaultFullImeList = defaultFullImeCfg.defaultFullImeList;
+    return ret;
+}
+
 std::string SysCfgParser::GetSysCfgContent(const std::string &key)
 {
     std::string content;

test/unittest/cpp_test/mock/ime_info_inquirer.cpp

@@ -20,6 +20,7 @@ namespace MiscServices {
 std::shared_ptr<ImeInfo> ImeInfoInquirer::defaultIme_ = nullptr;
 std::shared_ptr<Property> ImeInfoInquirer::defaultImeProperty_ = nullptr;
 std::shared_ptr<Property> ImeInfoInquirer::currentIme_ = nullptr;
+constexpr const char *MOCK_APP_ID = "MockAppId";
 ImeInfoInquirer &ImeInfoInquirer::GetInstance()
 {
     static ImeInfoInquirer instance;
@@ -40,5 +41,11 @@ std::shared_ptr<Property> ImeInfoInquirer::GetDefaultImeCfgProp()
 {
     return defaultImeProperty_;
 }
+
+bool GetImeAppId(int32_t userId, const std::string &bundleName, std::string &appId)
+{
+    appId = MOCK_APP_ID;
+    return true;
+}
 } // namespace MiscServices
 } // namespace OHOS

test/unittest/cpp_test/mock/ime_info_inquirer.h

@@ -32,6 +32,7 @@ public:
     std::shared_ptr<ImeInfo> GetDefaultImeInfo(int32_t userId);
     std::shared_ptr<Property> GetCurrentInputMethod(int32_t userId);
     std::shared_ptr<Property> GetDefaultImeCfgProp();
+    bool GetImeAppId(int32_t userId, const std::string &bundleName, std::string &appId);
 
 private:
     static std::shared_ptr<ImeInfo> defaultIme_;