1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "ability_resident_process_rdb.h"
17 
18 #include "hilog_tag_wrapper.h"
19 #include "parser_util.h"
20 
21 namespace OHOS {
22 namespace AbilityRuntime {
23 namespace {
24 const std::string ABILITY_RDB_TABLE_NAME = "resident_process_list";
25 const std::string KEY_BUNDLE_NAME = "KEY_BUNDLE_NAME";
26 const std::string KEY_KEEP_ALIVE_ENABLE = "KEEP_ALIVE_ENABLE";
27 const std::string KEY_KEEP_ALIVE_CONFIGURED_LIST = "KEEP_ALIVE_CONFIGURED_LIST";
28 
29 const int32_t INDEX_BUNDLE_NAME = 0;
30 const int32_t INDEX_KEEP_ALIVE_ENABLE = 1;
31 const int32_t INDEX_KEEP_ALIVE_CONFIGURED_LIST = 2;
32 } // namespace
33 
AmsResidentProcessRdbCallBack(const AmsRdbConfig &rdbConfig)34 AmsResidentProcessRdbCallBack::AmsResidentProcessRdbCallBack(const AmsRdbConfig &rdbConfig) : rdbConfig_(rdbConfig) {}
35 
OnCreate(NativeRdb::RdbStore &rdbStore)36 int32_t AmsResidentProcessRdbCallBack::OnCreate(NativeRdb::RdbStore &rdbStore)
37 {
38     TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
39 
40     std::string createTableSql = "CREATE TABLE IF NOT EXISTS " + rdbConfig_.tableName +
41                                  " (KEY_BUNDLE_NAME TEXT NOT NULL PRIMARY KEY," +
42                                  "KEEP_ALIVE_ENABLE TEXT NOT NULL, KEEP_ALIVE_CONFIGURED_LIST TEXT NOT NULL);";
43     auto sqlResult = rdbStore.ExecuteSql(createTableSql);
44     if (sqlResult != NativeRdb::E_OK) {
45         TAG_LOGE(AAFwkTag::ABILITYMGR, "execute sql error");
46         return sqlResult;
47     }
48 
49     auto &parser = ParserUtil::GetInstance();
50     std::vector<std::tuple<std::string, std::string, std::string>> initList;
51     parser.GetResidentProcessRawData(initList);
52 
53     std::vector<NativeRdb::ValuesBucket> valuesBuckets;
54     for (const auto &item : initList) {
55         NativeRdb::ValuesBucket valuesBucket;
56         valuesBucket.PutString(KEY_BUNDLE_NAME, std::get<INDEX_BUNDLE_NAME>(item));
57         valuesBucket.PutString(KEY_KEEP_ALIVE_ENABLE, std::get<INDEX_KEEP_ALIVE_ENABLE>(item));
58         valuesBucket.PutString(KEY_KEEP_ALIVE_CONFIGURED_LIST, std::get<INDEX_KEEP_ALIVE_CONFIGURED_LIST>(item));
59 
60         valuesBuckets.emplace_back(valuesBucket);
61     }
62 
63     int64_t rowId = -1;
64     int64_t insertNum = 0;
65     int32_t ret = rdbStore.BatchInsert(insertNum, rdbConfig_.tableName, valuesBuckets);
66     if (ret != NativeRdb::E_OK) {
67         TAG_LOGE(AAFwkTag::ABILITYMGR, "batch insert error[%{public}d]", ret);
68         return ret;
69     }
70     return NativeRdb::E_OK;
71 }
72 
OnUpgrade(NativeRdb::RdbStore &rdbStore, int currentVersion, int targetVersion)73 int32_t AmsResidentProcessRdbCallBack::OnUpgrade(NativeRdb::RdbStore &rdbStore, int currentVersion, int targetVersion)
74 {
75     TAG_LOGI(AAFwkTag::ABILITYMGR, "onUpgrade current:%{plubic}d, target:%{plubic}d", currentVersion,
76         targetVersion);
77     return NativeRdb::E_OK;
78 }
79 
OnDowngrade(NativeRdb::RdbStore &rdbStore, int currentVersion, int targetVersion)80 int32_t AmsResidentProcessRdbCallBack::OnDowngrade(NativeRdb::RdbStore &rdbStore, int currentVersion, int targetVersion)
81 {
82     TAG_LOGI(AAFwkTag::ABILITYMGR, "onDowngrade current:%{plubic}d, target:%{plubic}d", currentVersion,
83         targetVersion);
84     return NativeRdb::E_OK;
85 }
86 
OnOpen(NativeRdb::RdbStore &rdbStore)87 int32_t AmsResidentProcessRdbCallBack::OnOpen(NativeRdb::RdbStore &rdbStore)
88 {
89     TAG_LOGI(AAFwkTag::ABILITYMGR, "OnOpen");
90     return NativeRdb::E_OK;
91 }
92 
onCorruption(std::string databaseFile)93 int32_t AmsResidentProcessRdbCallBack::onCorruption(std::string databaseFile)
94 {
95     TAG_LOGI(AAFwkTag::ABILITYMGR, "onCorruption");
96     return NativeRdb::E_OK;
97 }
98 
Init()99 int32_t AmsResidentProcessRdb::Init()
100 {
101     if (rdbMgr_ != nullptr) {
102         TAG_LOGD(AAFwkTag::ABILITYMGR, "rdb mgr existed");
103         return Rdb_OK;
104     }
105 
106     AmsRdbConfig config;
107     config.tableName = ABILITY_RDB_TABLE_NAME;
108     rdbMgr_ = std::make_unique<RdbDataManager>(config);
109     if (rdbMgr_ == nullptr) {
110         TAG_LOGE(AAFwkTag::ABILITYMGR, "create object fail");
111         return Rdb_Init_Err;
112     }
113 
114     AmsResidentProcessRdbCallBack amsCallback(config);
115     if (rdbMgr_->Init(amsCallback) != Rdb_OK) {
116         return Rdb_Init_Err;
117     }
118 
119     return Rdb_OK;
120 }
121 
GetInstance()122 AmsResidentProcessRdb &AmsResidentProcessRdb::GetInstance()
123 {
124     static AmsResidentProcessRdb instance;
125     return instance;
126 }
127 
VerifyConfigurationPermissions( const std::string &bundleName, const std::string &callerBundleName)128 int32_t AmsResidentProcessRdb::VerifyConfigurationPermissions(
129     const std::string &bundleName, const std::string &callerBundleName)
130 {
131     if (bundleName.empty() || callerBundleName.empty()) {
132         TAG_LOGE(AAFwkTag::ABILITYMGR, "null bundle name");
133         return Rdb_Parameter_Err;
134     }
135 
136     if (bundleName == callerBundleName) {
137         TAG_LOGD(AAFwkTag::ABILITYMGR, "The caller and the called are the same.");
138         return Rdb_OK;
139     }
140 
141     if (rdbMgr_ == nullptr) {
142         TAG_LOGE(AAFwkTag::ABILITYMGR, "rdb mgr error");
143         return Rdb_Parameter_Err;
144     }
145 
146     NativeRdb::AbsRdbPredicates absRdbPredicates(ABILITY_RDB_TABLE_NAME);
147     absRdbPredicates.EqualTo(KEY_BUNDLE_NAME, bundleName);
148     auto absSharedResultSet = rdbMgr_->QueryData(absRdbPredicates);
149     if (absSharedResultSet == nullptr) {
150         TAG_LOGE(AAFwkTag::ABILITYMGR, "null absSharedResultSet");
151         return Rdb_Permissions_Err;
152     }
153 
154     ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
155     auto ret = absSharedResultSet->GoToFirstRow();
156     if (ret != NativeRdb::E_OK) {
157         TAG_LOGE(AAFwkTag::ABILITYMGR, "fail, ret:%{public}d", ret);
158         return Rdb_Search_Record_Err;
159     }
160 
161     std::string KeepAliveConfiguredList;
162     ret = absSharedResultSet->GetString(INDEX_KEEP_ALIVE_CONFIGURED_LIST, KeepAliveConfiguredList);
163     if (ret != NativeRdb::E_OK) {
164         TAG_LOGE(AAFwkTag::ABILITYMGR, "fail, ret: %{public}d", ret);
165         return Rdb_Search_Record_Err;
166     }
167 
168     if (KeepAliveConfiguredList.find(callerBundleName) != std::string::npos) {
169         return Rdb_OK;
170     }
171 
172     return Rdb_Permissions_Err;
173 }
174 
GetResidentProcessEnable(const std::string &bundleName, bool &enable)175 int32_t AmsResidentProcessRdb::GetResidentProcessEnable(const std::string &bundleName, bool &enable)
176 {
177     if (bundleName.empty()) {
178         TAG_LOGE(AAFwkTag::ABILITYMGR, "null bundleName");
179         return Rdb_Parameter_Err;
180     }
181 
182     if (rdbMgr_ == nullptr) {
183         TAG_LOGE(AAFwkTag::ABILITYMGR, "rdb mgr error");
184         return Rdb_Parameter_Err;
185     }
186 
187     NativeRdb::AbsRdbPredicates absRdbPredicates(ABILITY_RDB_TABLE_NAME);
188     absRdbPredicates.EqualTo(KEY_BUNDLE_NAME, bundleName);
189     auto absSharedResultSet = rdbMgr_->QueryData(absRdbPredicates);
190     if (absSharedResultSet == nullptr) {
191         TAG_LOGE(AAFwkTag::ABILITYMGR, "rdb query fail");
192         return Rdb_Permissions_Err;
193     }
194 
195     ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
196     auto ret = absSharedResultSet->GoToFirstRow();
197     if (ret != NativeRdb::E_OK) {
198         TAG_LOGD(AAFwkTag::ABILITYMGR, "fail, ret: %{public}d", ret);
199         return Rdb_Search_Record_Err;
200     }
201 
202     std::string flag;
203     ret = absSharedResultSet->GetString(INDEX_KEEP_ALIVE_ENABLE, flag);
204     if (ret != NativeRdb::E_OK) {
205         TAG_LOGE(AAFwkTag::ABILITYMGR, "fail, ret: %{public}d", ret);
206         return Rdb_Search_Record_Err;
207     }
208     try {
209         enable = static_cast<bool>(std::stoul(flag));
210     } catch (...) {
211         TAG_LOGE(AAFwkTag::ABILITYMGR, "stoul fail, flag: %{public}s", flag.c_str());
212         return Rdb_Search_Record_Err;
213     }
214 
215     return Rdb_OK;
216 }
217 
UpdateResidentProcessEnable(const std::string &bundleName, bool enable)218 int32_t AmsResidentProcessRdb::UpdateResidentProcessEnable(const std::string &bundleName, bool enable)
219 {
220     if (bundleName.empty()) {
221         TAG_LOGE(AAFwkTag::ABILITYMGR, "null bundleName");
222         return Rdb_Parameter_Err;
223     }
224 
225     if (rdbMgr_ == nullptr) {
226         TAG_LOGE(AAFwkTag::ABILITYMGR, "rdb mgr error");
227         return Rdb_Parameter_Err;
228     }
229 
230     NativeRdb::ValuesBucket valuesBucket;
231     valuesBucket.PutString(KEY_KEEP_ALIVE_ENABLE, std::to_string(enable));
232     NativeRdb::AbsRdbPredicates absRdbPredicates(ABILITY_RDB_TABLE_NAME);
233     absRdbPredicates.EqualTo(KEY_BUNDLE_NAME, bundleName);
234     return rdbMgr_->UpdateData(valuesBucket, absRdbPredicates);
235 }
236 
RemoveData(std::string &bundleName)237 int32_t AmsResidentProcessRdb::RemoveData(std::string &bundleName)
238 {
239     if (bundleName.empty()) {
240         TAG_LOGE(AAFwkTag::ABILITYMGR, "null bundleName");
241         return Rdb_Parameter_Err;
242     }
243 
244     if (rdbMgr_ == nullptr) {
245         TAG_LOGE(AAFwkTag::ABILITYMGR, "rdb mgr error");
246         return Rdb_Parameter_Err;
247     }
248     NativeRdb::AbsRdbPredicates absRdbPredicates(ABILITY_RDB_TABLE_NAME);
249     absRdbPredicates.EqualTo(KEY_BUNDLE_NAME, bundleName);
250     return rdbMgr_->DeleteData(absRdbPredicates);
251 }
252 } // namespace AbilityRuntime
253 } // namespace OHOS
254