1 /*
2 * Copyright (c) 2023-2025 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 "bundle_resource_rdb.h"
17
18 #include "app_log_wrapper.h"
19 #include "bundle_resource_constants.h"
20 #include "bundle_util.h"
21 #include "hitrace_meter.h"
22 #include "scope_guard.h"
23
24 namespace OHOS {
25 namespace AppExecFwk {
26 namespace {
27 constexpr const char* SYSTEM_RESOURCES_APP = "ohos.global.systemres";
28 }
29
BundleResourceRdb()30 BundleResourceRdb::BundleResourceRdb()
31 {
32 APP_LOGI_NOFUNC("BundleResourceRdb create");
33 BmsRdbConfig bmsRdbConfig;
34 bmsRdbConfig.dbName = BundleResourceConstants::BUNDLE_RESOURCE_RDB_NAME;
35 bmsRdbConfig.dbPath = BundleResourceConstants::BUNDLE_RESOURCE_RDB_PATH;
36 bmsRdbConfig.tableName = BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME;
37 bmsRdbConfig.createTableSql = std::string(
38 "CREATE TABLE IF NOT EXISTS "
39 + std::string(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME)
40 + "(NAME TEXT NOT NULL, UPDATE_TIME INTEGER, LABEL TEXT, ICON TEXT, "
41 + "SYSTEM_STATE TEXT NOT NULL, PRIMARY KEY (NAME));");
42 bmsRdbConfig.insertColumnSql.push_back(std::string("ALTER TABLE " +
43 std::string(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME) +
44 " ADD FOREGROUND BLOB;"));
45 bmsRdbConfig.insertColumnSql.push_back(std::string("ALTER TABLE " +
46 std::string(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME) +
47 " ADD BACKGROUND BLOB;"));
48 rdbDataManager_ = std::make_shared<RdbDataManager>(bmsRdbConfig);
49 rdbDataManager_->CreateTable();
50 }
51
~BundleResourceRdb()52 BundleResourceRdb::~BundleResourceRdb()
53 {
54 }
55
AddResourceInfo(const ResourceInfo & resourceInfo)56 bool BundleResourceRdb::AddResourceInfo(const ResourceInfo &resourceInfo)
57 {
58 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
59 if (resourceInfo.bundleName_.empty()) {
60 APP_LOGE("failed, bundleName is empty");
61 return false;
62 }
63 APP_LOGD("insert resource key:%{public}s", resourceInfo.GetKey().c_str());
64 int64_t timeStamp = BundleUtil::GetCurrentTimeMs();
65 NativeRdb::ValuesBucket valuesBucket;
66 valuesBucket.PutString(BundleResourceConstants::NAME, resourceInfo.GetKey());
67 valuesBucket.PutLong(BundleResourceConstants::UPDATE_TIME, timeStamp);
68 valuesBucket.PutString(BundleResourceConstants::LABEL, resourceInfo.label_);
69 valuesBucket.PutString(BundleResourceConstants::ICON, resourceInfo.icon_);
70 valuesBucket.PutString(BundleResourceConstants::SYSTEM_STATE, BundleSystemState::GetInstance().ToString());
71 // used for layered icons
72 valuesBucket.PutBlob(BundleResourceConstants::FOREGROUND, resourceInfo.foreground_);
73 valuesBucket.PutBlob(BundleResourceConstants::BACKGROUND, resourceInfo.background_);
74 APP_LOGD("key:%{public}s foreground: %{public}zu, background: %{public}zu", resourceInfo.GetKey().c_str(),
75 resourceInfo.foreground_.size(), resourceInfo.background_.size());
76
77 return rdbDataManager_->InsertData(valuesBucket);
78 }
79
AddResourceInfos(const std::vector<ResourceInfo> & resourceInfos)80 bool BundleResourceRdb::AddResourceInfos(const std::vector<ResourceInfo> &resourceInfos)
81 {
82 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
83 if (resourceInfos.empty()) {
84 APP_LOGE("failed, resourceInfos is empty");
85 return false;
86 }
87 int64_t timeStamp = BundleUtil::GetCurrentTimeMs();
88 bool ret = true;
89 std::vector<NativeRdb::ValuesBucket> valuesBuckets;
90 for (const auto &info : resourceInfos) {
91 if (info.bundleName_.empty()) {
92 APP_LOGE("failed, bundleName is empty");
93 ret = false;
94 continue;
95 }
96 NativeRdb::ValuesBucket valuesBucket;
97 valuesBucket.PutString(BundleResourceConstants::NAME, info.GetKey());
98 valuesBucket.PutLong(BundleResourceConstants::UPDATE_TIME, timeStamp);
99 valuesBucket.PutString(BundleResourceConstants::SYSTEM_STATE, BundleSystemState::GetInstance().ToString());
100
101 if (!info.label_.empty()) {
102 valuesBucket.PutString(BundleResourceConstants::LABEL, info.label_);
103 } else {
104 valuesBucket.PutString(BundleResourceConstants::LABEL, resourceInfos[0].label_);
105 }
106
107 if (!info.icon_.empty()) {
108 valuesBucket.PutString(BundleResourceConstants::ICON, info.icon_);
109 // used for layered icons
110 valuesBucket.PutBlob(BundleResourceConstants::FOREGROUND, info.foreground_);
111 valuesBucket.PutBlob(BundleResourceConstants::BACKGROUND, info.background_);
112 } else {
113 valuesBucket.PutString(BundleResourceConstants::ICON, resourceInfos[0].icon_);
114 // used for layered icons
115 valuesBucket.PutBlob(BundleResourceConstants::FOREGROUND, resourceInfos[0].foreground_);
116 valuesBucket.PutBlob(BundleResourceConstants::BACKGROUND, resourceInfos[0].background_);
117 }
118 APP_LOGD("key:%{public}s foreground: %{public}zu, background: %{public}zu", info.GetKey().c_str(),
119 info.foreground_.size(), info.background_.size());
120 valuesBuckets.emplace_back(valuesBucket);
121 }
122 int64_t insertNum = 0;
123 bool insertRet = rdbDataManager_->BatchInsert(insertNum, valuesBuckets);
124 if (!insertRet) {
125 APP_LOGE("BatchInsert failed");
126 return false;
127 }
128 if (valuesBuckets.size() != static_cast<uint64_t>(insertNum)) {
129 APP_LOGE("BatchInsert size not expected");
130 return false;
131 }
132 return ret;
133 }
134
DeleteResourceInfo(const std::string & key)135 bool BundleResourceRdb::DeleteResourceInfo(const std::string &key)
136 {
137 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
138 if (key.empty()) {
139 APP_LOGE("failed, key is empty");
140 return false;
141 }
142 APP_LOGD("need delete resource info, key: %{public}s", key.c_str());
143 /**
144 * begin with bundle name, like:
145 * 1. bundleName
146 * 2. bundleName/moduleName/abilityName
147 */
148 if (key.find(ServiceConstants::PATH_SEPARATOR) == std::string::npos) {
149 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
150 // need delete both bundle resource and launcher ability resource
151 absRdbPredicates.BeginsWith(BundleResourceConstants::NAME, key + ServiceConstants::PATH_SEPARATOR);
152 if (!rdbDataManager_->DeleteData(absRdbPredicates)) {
153 APP_LOGW("delete key:%{public}s failed", key.c_str());
154 }
155 }
156 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
157 absRdbPredicates.EqualTo(BundleResourceConstants::NAME, key);
158 return rdbDataManager_->DeleteData(absRdbPredicates);
159 }
160
GetAllResourceName(std::vector<std::string> & keyNames)161 bool BundleResourceRdb::GetAllResourceName(std::vector<std::string> &keyNames)
162 {
163 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
164 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
165 std::string systemState = BundleSystemState::GetInstance().ToString();
166 APP_LOGI("start get all resource name:%{public}s", systemState.c_str());
167 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
168 if (absSharedResultSet == nullptr) {
169 APP_LOGE("QueryByStep failed, systemState:%{public}s", systemState.c_str());
170 return false;
171 }
172 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
173
174 auto ret = absSharedResultSet->GoToFirstRow();
175 if (ret != NativeRdb::E_OK) {
176 APP_LOGE("GoToFirstRow failed, ret %{public}d, systemState %{public}s", ret, systemState.c_str());
177 return false;
178 }
179 do {
180 std::string name;
181 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_NAME, name);
182 if (ret != NativeRdb::E_OK) {
183 APP_LOGE("GetString name failed, ret %{public}d, systemState %{public}s", ret, systemState.c_str());
184 return false;
185 }
186 if (name.find("/") != std::string::npos) {
187 continue;
188 }
189 // icon is invalid, need add again
190 std::vector<uint8_t> foreground;
191 ret = absSharedResultSet->GetBlob(BundleResourceConstants::INDEX_FOREGROUND, foreground);
192 if (ret != NativeRdb::E_OK) {
193 APP_LOGE("GetString foreground failed, ret %{public}d, systemState %{public}s", ret, systemState.c_str());
194 return false;
195 }
196 if (foreground.empty()) {
197 APP_LOGW("keyName %{public}s foreground invalid", name.c_str());
198 continue;
199 }
200 // label is invalid, need add again
201 std::string label;
202 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_LABEL, label);
203 if (ret != NativeRdb::E_OK) {
204 APP_LOGE("GetString label failed, ret %{public}d, systemState:%{public}s", ret, systemState.c_str());
205 return false;
206 }
207 if ((label.find('$') == 0) || (label == name) || label.empty()) {
208 APP_LOGW("keyName %{public}s label invalid", name.c_str());
209 continue;
210 }
211 keyNames.push_back(name);
212 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
213 APP_LOGI_NOFUNC("end");
214 return true;
215 }
216
GetResourceNameByBundleName(const std::string & bundleName,const int32_t appIndex,std::vector<std::string> & keyName)217 bool BundleResourceRdb::GetResourceNameByBundleName(
218 const std::string &bundleName,
219 const int32_t appIndex,
220 std::vector<std::string> &keyName)
221 {
222 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
223 APP_LOGI_NOFUNC("GetResourceName -n %{public}s -i %{public}d", bundleName.c_str(), appIndex);
224 if (bundleName.empty()) {
225 APP_LOGE("bundleName is empty");
226 return false;
227 }
228 ResourceInfo resourceInfo;
229 resourceInfo.bundleName_ = bundleName;
230 resourceInfo.appIndex_ = appIndex;
231 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
232 absRdbPredicates.BeginsWith(BundleResourceConstants::NAME, resourceInfo.GetKey() +
233 BundleResourceConstants::SEPARATOR);
234 std::string systemState = BundleSystemState::GetInstance().ToString();
235
236 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
237 if (absSharedResultSet == nullptr) {
238 APP_LOGE("bundleName:%{public}s failed due rdb QueryByStep failed, systemState:%{public}s",
239 bundleName.c_str(), systemState.c_str());
240 return false;
241 }
242 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
243 auto ret = absSharedResultSet->GoToFirstRow();
244 if (ret != NativeRdb::E_OK) {
245 APP_LOGD("bundleName:%{public}s not exist, ret: %{public}d, systemState:%{public}s",
246 bundleName.c_str(), ret, systemState.c_str());
247 return false;
248 }
249
250 do {
251 std::string key;
252 auto ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_NAME, key);
253 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString name failed, ret: %{public}d");
254 keyName.emplace_back(key);
255 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
256 APP_LOGI_NOFUNC("end");
257 return true;
258 }
259
DeleteAllResourceInfo()260 bool BundleResourceRdb::DeleteAllResourceInfo()
261 {
262 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
263 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
264 // delete all resource info
265 return rdbDataManager_->DeleteData(absRdbPredicates);
266 }
267
GetBundleResourceInfo(const std::string & bundleName,const uint32_t flags,BundleResourceInfo & bundleResourceInfo,int32_t appIndex)268 bool BundleResourceRdb::GetBundleResourceInfo(
269 const std::string &bundleName,
270 const uint32_t flags,
271 BundleResourceInfo &bundleResourceInfo,
272 int32_t appIndex)
273 {
274 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
275 APP_LOGI_NOFUNC("rdb -n %{public}s -i %{public}d", bundleName.c_str(), appIndex);
276 if (bundleName.empty()) {
277 APP_LOGE("bundleName is empty");
278 return false;
279 }
280 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
281 ResourceInfo resourceInfo;
282 resourceInfo.bundleName_ = bundleName;
283 resourceInfo.appIndex_ = appIndex;
284 absRdbPredicates.EqualTo(BundleResourceConstants::NAME, resourceInfo.GetKey());
285 std::string systemState = BundleSystemState::GetInstance().ToString();
286
287 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
288 if (absSharedResultSet == nullptr) {
289 APP_LOGE("rdb QueryByStep failed, bundleName %{public}s appIndex %{public}d, %{public}s",
290 bundleName.c_str(), appIndex, systemState.c_str());
291 return false;
292 }
293
294 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
295 auto ret = absSharedResultSet->GoToFirstRow();
296 if (ret != NativeRdb::E_OK) {
297 APP_LOGE_NOFUNC("rdb GetBundleResourceInfo -n %{public}s failed:%{public}d systemState:%{public}s",
298 bundleName.c_str(), ret, systemState.c_str());
299 return false;
300 }
301 APP_LOGI_NOFUNC("rdb end");
302 return ConvertToBundleResourceInfo(absSharedResultSet, flags, bundleResourceInfo);
303 }
304
GetLauncherAbilityResourceInfo(const std::string & bundleName,const uint32_t flags,std::vector<LauncherAbilityResourceInfo> & launcherAbilityResourceInfos,const int32_t appIndex)305 bool BundleResourceRdb::GetLauncherAbilityResourceInfo(
306 const std::string &bundleName,
307 const uint32_t flags,
308 std::vector<LauncherAbilityResourceInfo> &launcherAbilityResourceInfos,
309 const int32_t appIndex)
310 {
311 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
312 APP_LOGI_NOFUNC("rdb GetLauncherAbilityResourceInfo -n %{public}s -i %{public}d", bundleName.c_str(), appIndex);
313 if (bundleName.empty()) {
314 APP_LOGE("bundleName is empty");
315 return false;
316 }
317 ResourceInfo resourceInfo;
318 resourceInfo.bundleName_ = bundleName;
319 resourceInfo.appIndex_ = appIndex;
320 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
321 absRdbPredicates.BeginsWith(BundleResourceConstants::NAME, resourceInfo.GetKey() +
322 BundleResourceConstants::SEPARATOR);
323 std::string systemState = BundleSystemState::GetInstance().ToString();
324
325 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
326 if (absSharedResultSet == nullptr) {
327 APP_LOGE("QueryByStep failed bundleName %{public}s failed, systemState %{public}s",
328 bundleName.c_str(), systemState.c_str());
329 return false;
330 }
331 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
332 auto ret = absSharedResultSet->GoToFirstRow();
333 if (ret != NativeRdb::E_OK) {
334 APP_LOGE("bundleName %{public}s GoToFirstRow failed, ret %{public}d, systemState:%{public}s",
335 bundleName.c_str(), ret, systemState.c_str());
336 return false;
337 }
338
339 do {
340 LauncherAbilityResourceInfo resourceInfo;
341 if (ConvertToLauncherAbilityResourceInfo(absSharedResultSet, flags, resourceInfo)) {
342 launcherAbilityResourceInfos.push_back(resourceInfo);
343 }
344 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
345
346 if ((flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) ==
347 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) {
348 APP_LOGD("need sort by label");
349 std::sort(launcherAbilityResourceInfos.begin(), launcherAbilityResourceInfos.end(),
350 [](LauncherAbilityResourceInfo &resourceA, LauncherAbilityResourceInfo &resourceB) {
351 return resourceA.label < resourceB.label;
352 });
353 }
354 APP_LOGI_NOFUNC("end");
355 return !launcherAbilityResourceInfos.empty();
356 }
357
GetAllBundleResourceInfo(const uint32_t flags,std::vector<BundleResourceInfo> & bundleResourceInfos)358 bool BundleResourceRdb::GetAllBundleResourceInfo(const uint32_t flags,
359 std::vector<BundleResourceInfo> &bundleResourceInfos)
360 {
361 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
362 APP_LOGI("start get all bundle resource");
363 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
364 std::string systemState = BundleSystemState::GetInstance().ToString();
365
366 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
367 if (absSharedResultSet == nullptr) {
368 APP_LOGE("absSharedResultSet nullptr, systemState %{public}s", systemState.c_str());
369 return false;
370 }
371 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
372 auto ret = absSharedResultSet->GoToFirstRow();
373 if (ret != NativeRdb::E_OK) {
374 APP_LOGE("GoToFirstRow failed, ret %{public}d, systemState %{public}s", ret, systemState.c_str());
375 return false;
376 }
377
378 do {
379 BundleResourceInfo resourceInfo;
380 if (ConvertToBundleResourceInfo(absSharedResultSet, flags, resourceInfo)) {
381 bundleResourceInfos.push_back(resourceInfo);
382 }
383 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
384
385 if ((flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) ==
386 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) {
387 APP_LOGD("need sort by label");
388 std::sort(bundleResourceInfos.begin(), bundleResourceInfos.end(),
389 [](BundleResourceInfo &resourceA, BundleResourceInfo &resourceB) {
390 return resourceA.label < resourceB.label;
391 });
392 }
393 APP_LOGI_NOFUNC("end");
394 return !bundleResourceInfos.empty();
395 }
396
GetAllLauncherAbilityResourceInfo(const uint32_t flags,std::vector<LauncherAbilityResourceInfo> & launcherAbilityResourceInfos)397 bool BundleResourceRdb::GetAllLauncherAbilityResourceInfo(const uint32_t flags,
398 std::vector<LauncherAbilityResourceInfo> &launcherAbilityResourceInfos)
399 {
400 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
401 APP_LOGI("start get all launcher resource");
402 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
403 absRdbPredicates.Contains(BundleResourceConstants::NAME, BundleResourceConstants::SEPARATOR);
404 std::string systemState = BundleSystemState::GetInstance().ToString();
405
406 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
407 if (absSharedResultSet == nullptr) {
408 APP_LOGE("absSharedResultSet nullptr, systemState %{public}s", systemState.c_str());
409 return false;
410 }
411
412 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
413 auto ret = absSharedResultSet->GoToFirstRow();
414 if (ret != NativeRdb::E_OK) {
415 APP_LOGE("GoToFirstRow failed, ret %{public}d, systemState %{public}s", ret, systemState.c_str());
416 return false;
417 }
418
419 do {
420 LauncherAbilityResourceInfo resourceInfo;
421 if (ConvertToLauncherAbilityResourceInfo(absSharedResultSet, flags, resourceInfo)) {
422 launcherAbilityResourceInfos.push_back(resourceInfo);
423 }
424 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
425
426 if ((flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) ==
427 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) {
428 std::sort(launcherAbilityResourceInfos.begin(), launcherAbilityResourceInfos.end(),
429 [](LauncherAbilityResourceInfo &resourceA, LauncherAbilityResourceInfo &resourceB) {
430 return resourceA.label < resourceB.label;
431 });
432 }
433 APP_LOGI_NOFUNC("end");
434 return !launcherAbilityResourceInfos.empty();
435 }
436
ConvertToBundleResourceInfo(const std::shared_ptr<NativeRdb::ResultSet> & absSharedResultSet,const uint32_t flags,BundleResourceInfo & bundleResourceInfo)437 bool BundleResourceRdb::ConvertToBundleResourceInfo(
438 const std::shared_ptr<NativeRdb::ResultSet> &absSharedResultSet,
439 const uint32_t flags,
440 BundleResourceInfo &bundleResourceInfo)
441 {
442 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
443 if (absSharedResultSet == nullptr) {
444 APP_LOGE("absSharedResultSet is nullptr");
445 return false;
446 }
447 auto ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_NAME, bundleResourceInfo.bundleName);
448 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString name failed, ret: %{public}d");
449 if (bundleResourceInfo.bundleName.find_first_of(BundleResourceConstants::SEPARATOR) != std::string::npos) {
450 APP_LOGD("key:%{public}s not bundle resource info, continue", bundleResourceInfo.bundleName.c_str());
451 return false;
452 }
453 ParseKey(bundleResourceInfo.bundleName, bundleResourceInfo);
454
455 bool getAll = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL)) ==
456 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL);
457
458 bool getLabel = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_LABEL)) ==
459 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_LABEL);
460 if (getAll || getLabel) {
461 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_LABEL, bundleResourceInfo.label);
462 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString label failed, ret: %{public}d");
463 }
464
465 bool getIcon = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_ICON)) ==
466 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_ICON);
467 if (getAll || getIcon) {
468 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_ICON, bundleResourceInfo.icon);
469 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString label icon, ret: %{public}d");
470 }
471
472 bool getDrawable = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR)) ==
473 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR);
474 if (getDrawable) {
475 ret = absSharedResultSet->GetBlob(BundleResourceConstants::INDEX_FOREGROUND, bundleResourceInfo.foreground);
476 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetBlob foreground, ret: %{public}d");
477
478 ret = absSharedResultSet->GetBlob(BundleResourceConstants::INDEX_BACKGROUND, bundleResourceInfo.background);
479 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetBlob background, ret: %{public}d");
480 }
481 return true;
482 }
483
ConvertToLauncherAbilityResourceInfo(const std::shared_ptr<NativeRdb::ResultSet> & absSharedResultSet,const uint32_t flags,LauncherAbilityResourceInfo & launcherAbilityResourceInfo)484 bool BundleResourceRdb::ConvertToLauncherAbilityResourceInfo(
485 const std::shared_ptr<NativeRdb::ResultSet> &absSharedResultSet,
486 const uint32_t flags,
487 LauncherAbilityResourceInfo &launcherAbilityResourceInfo)
488 {
489 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
490 if (absSharedResultSet == nullptr) {
491 APP_LOGE("absSharedResultSet is nullptr");
492 return false;
493 }
494 std::string key;
495 auto ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_NAME, key);
496 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString name failed, ret: %{public}d");
497 ParseKey(key, launcherAbilityResourceInfo);
498 if (launcherAbilityResourceInfo.extensionAbilityType != -1) {
499 return false;
500 }
501 if (launcherAbilityResourceInfo.moduleName.empty() || launcherAbilityResourceInfo.abilityName.empty()) {
502 APP_LOGW("key:%{public}s not launcher ability resource info", key.c_str());
503 return false;
504 }
505 bool getAll = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL)) ==
506 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL);
507 bool getLabel = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_LABEL)) ==
508 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_LABEL);
509 if (getAll || getLabel) {
510 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_LABEL, launcherAbilityResourceInfo.label);
511 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString label failed, ret: %{public}d");
512 }
513
514 bool getIcon = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_ICON)) ==
515 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_ICON);
516 if (getAll || getIcon) {
517 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_ICON, launcherAbilityResourceInfo.icon);
518 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString label icon, ret: %{public}d");
519 }
520
521 bool getDrawable = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR)) ==
522 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR);
523 if (getDrawable) {
524 ret = absSharedResultSet->GetBlob(BundleResourceConstants::INDEX_FOREGROUND,
525 launcherAbilityResourceInfo.foreground);
526 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetBlob foreground, ret: %{public}d");
527
528 ret = absSharedResultSet->GetBlob(BundleResourceConstants::INDEX_BACKGROUND,
529 launcherAbilityResourceInfo.background);
530 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetBlob background, ret: %{public}d");
531 }
532 return true;
533 }
534
ConvertToExtensionAbilityResourceInfo(const std::shared_ptr<NativeRdb::ResultSet> & absSharedResultSet,const uint32_t flags,LauncherAbilityResourceInfo & launcherAbilityResourceInfo)535 bool BundleResourceRdb::ConvertToExtensionAbilityResourceInfo(
536 const std::shared_ptr<NativeRdb::ResultSet> &absSharedResultSet,
537 const uint32_t flags,
538 LauncherAbilityResourceInfo &launcherAbilityResourceInfo)
539 {
540 if (absSharedResultSet == nullptr) {
541 APP_LOGE("absSharedResultSet is nullptr");
542 return false;
543 }
544 std::string key;
545 auto ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_NAME, key);
546 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString name failed, ret: %{public}d");
547 ParseKey(key, launcherAbilityResourceInfo);
548 if (launcherAbilityResourceInfo.moduleName.empty() || launcherAbilityResourceInfo.abilityName.empty()) {
549 APP_LOGW("key:%{public}s not launcher ability resource info", key.c_str());
550 return false;
551 }
552 bool getAll = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL)) ==
553 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL);
554 bool getLabel = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_LABEL)) ==
555 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_LABEL);
556 if (getAll || getLabel) {
557 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_LABEL, launcherAbilityResourceInfo.label);
558 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString label failed, ret: %{public}d");
559 }
560
561 bool getIcon = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_ICON)) ==
562 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_ICON);
563 if (getAll || getIcon) {
564 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_ICON, launcherAbilityResourceInfo.icon);
565 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString label icon, ret: %{public}d");
566 }
567
568 bool getDrawable = (flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR)) ==
569 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR);
570 if (getDrawable) {
571 ret = absSharedResultSet->GetBlob(BundleResourceConstants::INDEX_FOREGROUND,
572 launcherAbilityResourceInfo.foreground);
573 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetBlob foreground, ret: %{public}d");
574
575 ret = absSharedResultSet->GetBlob(BundleResourceConstants::INDEX_BACKGROUND,
576 launcherAbilityResourceInfo.background);
577 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetBlob background, ret: %{public}d");
578 }
579 return true;
580 }
581
UpdateResourceForSystemStateChanged(const std::vector<ResourceInfo> & resourceInfos)582 bool BundleResourceRdb::UpdateResourceForSystemStateChanged(const std::vector<ResourceInfo> &resourceInfos)
583 {
584 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
585 if (resourceInfos.empty()) {
586 APP_LOGE("resourceInfos is empty");
587 return false;
588 }
589 std::string systemState = BundleSystemState::GetInstance().ToString();
590 int64_t timeStamp = BundleUtil::GetCurrentTimeMs();
591 bool ret = true;
592 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
593 for (const auto &resourceInfo : resourceInfos) {
594 NativeRdb::ValuesBucket valuesBucket;
595 valuesBucket.PutString(BundleResourceConstants::NAME, resourceInfo.GetKey());
596 valuesBucket.PutString(BundleResourceConstants::SYSTEM_STATE, systemState);
597 // process label
598 if (!resourceInfo.label_.empty()) {
599 valuesBucket.PutString(BundleResourceConstants::LABEL, resourceInfo.label_);
600 } else if (!resourceInfos[0].label_.empty()) {
601 valuesBucket.PutString(BundleResourceConstants::LABEL, resourceInfos[0].label_);
602 }
603 // process icon
604 if (!resourceInfo.icon_.empty()) {
605 valuesBucket.PutString(BundleResourceConstants::ICON, resourceInfo.icon_);
606 valuesBucket.PutBlob(BundleResourceConstants::FOREGROUND, resourceInfo.foreground_);
607 valuesBucket.PutBlob(BundleResourceConstants::BACKGROUND, resourceInfo.background_);
608 } else if (!resourceInfos[0].icon_.empty()) {
609 valuesBucket.PutString(BundleResourceConstants::ICON, resourceInfos[0].icon_);
610 valuesBucket.PutBlob(BundleResourceConstants::FOREGROUND, resourceInfos[0].foreground_);
611 valuesBucket.PutBlob(BundleResourceConstants::BACKGROUND, resourceInfos[0].background_);
612 }
613 valuesBucket.PutLong(BundleResourceConstants::UPDATE_TIME, timeStamp);
614 absRdbPredicates.EqualTo(BundleResourceConstants::NAME, resourceInfo.GetKey());
615 if (!rdbDataManager_->UpdateOrInsertData(valuesBucket, absRdbPredicates)) {
616 APP_LOGE("bundleName: %{public}s UpdateData failed", resourceInfo.GetKey().c_str());
617 ret = false;
618 }
619 absRdbPredicates.Clear();
620 }
621 return ret;
622 }
623
GetCurrentSystemState(std::string & systemState)624 bool BundleResourceRdb::GetCurrentSystemState(std::string &systemState)
625 {
626 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
627 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
628 absRdbPredicates.EqualTo(BundleResourceConstants::NAME, SYSTEM_RESOURCES_APP);
629 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
630 if (absSharedResultSet == nullptr) {
631 APP_LOGW("bundleName:%{public}s failed due rdb QueryByStep failed", SYSTEM_RESOURCES_APP);
632 return false;
633 }
634
635 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
636 auto ret = absSharedResultSet->GoToFirstRow();
637 if (ret != NativeRdb::E_OK) {
638 APP_LOGW("bundleName:%{public}s GoToFirstRow failed, ret: %{public}d", SYSTEM_RESOURCES_APP, ret);
639 return false;
640 }
641 ret = absSharedResultSet->GetString(BundleResourceConstants::INDEX_SYSTEM_STATE, systemState);
642 CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString name failed, ret: %{public}d");
643 APP_LOGI("current resource rdb systemState:%{public}s", systemState.c_str());
644 return true;
645 }
646
DeleteNotExistResourceInfo()647 bool BundleResourceRdb::DeleteNotExistResourceInfo()
648 {
649 HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
650 // need delete not current systemState resource
651 std::string systemState = BundleSystemState::GetInstance().ToString();
652 APP_LOGI_NOFUNC("current systemState:%{public}s", systemState.c_str());
653 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
654 absRdbPredicates.NotEqualTo(BundleResourceConstants::SYSTEM_STATE, systemState);
655 return rdbDataManager_->DeleteData(absRdbPredicates);
656 }
657
GetExtensionAbilityResourceInfo(const std::string & bundleName,const ExtensionAbilityType extensionAbilityType,const uint32_t flags,std::vector<LauncherAbilityResourceInfo> & extensionAbilityResourceInfo,const int32_t appIndex)658 bool BundleResourceRdb::GetExtensionAbilityResourceInfo(const std::string &bundleName,
659 const ExtensionAbilityType extensionAbilityType, const uint32_t flags,
660 std::vector<LauncherAbilityResourceInfo> &extensionAbilityResourceInfo, const int32_t appIndex)
661 {
662 ResourceInfo resourceInfo;
663 resourceInfo.bundleName_ = bundleName;
664 resourceInfo.appIndex_ = appIndex;
665 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
666 absRdbPredicates.BeginsWith(BundleResourceConstants::NAME, resourceInfo.GetKey() +
667 BundleResourceConstants::SEPARATOR);
668 std::string systemState = BundleSystemState::GetInstance().ToString();
669
670 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
671 if (absSharedResultSet == nullptr) {
672 APP_LOGE("QueryByStep failed bundleName %{public}s failed, systemState %{public}s",
673 bundleName.c_str(), systemState.c_str());
674 return false;
675 }
676 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
677 auto ret = absSharedResultSet->GoToFirstRow();
678 if (ret != NativeRdb::E_OK) {
679 APP_LOGE("bundleName %{public}s GoToFirstRow failed, ret %{public}d, systemState:%{public}s",
680 bundleName.c_str(), ret, systemState.c_str());
681 return false;
682 }
683
684 do {
685 LauncherAbilityResourceInfo resourceInfo;
686 if (ConvertToExtensionAbilityResourceInfo(absSharedResultSet, flags, resourceInfo)) {
687 if (resourceInfo.extensionAbilityType == static_cast<int32_t>(extensionAbilityType)) {
688 extensionAbilityResourceInfo.push_back(resourceInfo);
689 }
690 }
691 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
692
693 if ((flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) ==
694 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) {
695 std::sort(extensionAbilityResourceInfo.begin(), extensionAbilityResourceInfo.end(),
696 [](LauncherAbilityResourceInfo &resourceA, LauncherAbilityResourceInfo &resourceB) {
697 return resourceA.label < resourceB.label;
698 });
699 }
700 return !extensionAbilityResourceInfo.empty();
701 }
702
GetAllExtensionAbilityResourceInfo(const std::string & bundleName,const uint32_t flags,std::vector<LauncherAbilityResourceInfo> & extensionAbilityResourceInfo,const int32_t appIndex)703 bool BundleResourceRdb::GetAllExtensionAbilityResourceInfo(const std::string &bundleName, const uint32_t flags,
704 std::vector<LauncherAbilityResourceInfo> &extensionAbilityResourceInfo, const int32_t appIndex)
705 {
706 ResourceInfo resourceInfo;
707 resourceInfo.bundleName_ = bundleName;
708 resourceInfo.appIndex_ = appIndex;
709 NativeRdb::AbsRdbPredicates absRdbPredicates(BundleResourceConstants::BUNDLE_RESOURCE_RDB_TABLE_NAME);
710 absRdbPredicates.BeginsWith(BundleResourceConstants::NAME, resourceInfo.GetKey() +
711 BundleResourceConstants::SEPARATOR);
712 std::string systemState = BundleSystemState::GetInstance().ToString();
713
714 auto absSharedResultSet = rdbDataManager_->QueryByStep(absRdbPredicates);
715 if (absSharedResultSet == nullptr) {
716 APP_LOGE("QueryByStep failed bundleName %{public}s failed, systemState %{public}s",
717 bundleName.c_str(), systemState.c_str());
718 return false;
719 }
720 ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
721 auto ret = absSharedResultSet->GoToFirstRow();
722 if (ret != NativeRdb::E_OK) {
723 APP_LOGE("bundleName %{public}s GoToFirstRow failed, ret %{public}d, systemState:%{public}s",
724 bundleName.c_str(), ret, systemState.c_str());
725 return false;
726 }
727
728 do {
729 LauncherAbilityResourceInfo resourceInfo;
730 if (ConvertToExtensionAbilityResourceInfo(absSharedResultSet, flags, resourceInfo)) {
731 if (resourceInfo.extensionAbilityType >= 0) {
732 extensionAbilityResourceInfo.push_back(resourceInfo);
733 }
734 }
735 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
736
737 if ((flags & static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) ==
738 static_cast<uint32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL)) {
739 std::sort(extensionAbilityResourceInfo.begin(), extensionAbilityResourceInfo.end(),
740 [](LauncherAbilityResourceInfo &resourceA, LauncherAbilityResourceInfo &resourceB) {
741 return resourceA.label < resourceB.label;
742 });
743 }
744 return !extensionAbilityResourceInfo.empty();
745 }
746
ParseKey(const std::string & key,LauncherAbilityResourceInfo & launcherAbilityResourceInfo)747 void BundleResourceRdb::ParseKey(const std::string &key,
748 LauncherAbilityResourceInfo &launcherAbilityResourceInfo)
749 {
750 ResourceInfo info;
751 info.ParseKey(key);
752 launcherAbilityResourceInfo.bundleName = info.bundleName_;
753 launcherAbilityResourceInfo.moduleName = info.moduleName_;
754 launcherAbilityResourceInfo.abilityName = info.abilityName_;
755 launcherAbilityResourceInfo.appIndex = info.appIndex_;
756 launcherAbilityResourceInfo.extensionAbilityType = info.extensionAbilityType_;
757 }
758
ParseKey(const std::string & key,BundleResourceInfo & bundleResourceInfo)759 void BundleResourceRdb::ParseKey(const std::string &key,
760 BundleResourceInfo &bundleResourceInfo)
761 {
762 ResourceInfo info;
763 info.ParseKey(key);
764 bundleResourceInfo.bundleName = info.bundleName_;
765 bundleResourceInfo.appIndex = info.appIndex_;
766 }
767 } // AppExecFwk
768 } // OHOS
769