1 /*
2  * Copyright (c) 2023 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 "app_log_wrapper.h"
17 #include "app_log_tag_wrapper.h"
18 #include "bms_extension_client.h"
19 #include "bundle_mgr_service.h"
20 #include "hitrace_meter.h"
21 
22 namespace OHOS {
23 namespace AppExecFwk {
BmsExtensionClient()24 BmsExtensionClient::BmsExtensionClient()
25 {
26     APP_LOGD("create");
27     bmsExtensionImpl_ = std::make_shared<BmsExtensionDataMgr>();
28 }
29 
QueryLauncherAbility(const Want & want,int32_t userId,std::vector<AbilityInfo> & abilityInfos) const30 ErrCode BmsExtensionClient::QueryLauncherAbility(const Want &want, int32_t userId,
31     std::vector<AbilityInfo> &abilityInfos) const
32 {
33     LOG_D(BMS_TAG_QUERY, "start to query launcher abilities from bms extension");
34     auto dataMgr = GetDataMgr();
35     if (dataMgr == nullptr) {
36         LOG_W(BMS_TAG_QUERY, "dataMgr is nullptr");
37         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
38     }
39     if (userId != Constants::ALL_USERID) {
40         int32_t requestUserId = dataMgr->GetUserId(userId);
41         if (requestUserId == Constants::INVALID_USERID) {
42             return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
43         }
44     }
45 
46     std::string bundleName = want.GetElement().GetBundleName();
47     InnerBundleInfo info;
48     if (!bundleName.empty() && dataMgr->QueryInnerBundleInfo(bundleName, info)) {
49         LOG_D(BMS_TAG_QUERY, "bundle %{public}s has been existed and does not need to find in bms extension",
50             bundleName.c_str());
51         return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
52     }
53 
54     if (bmsExtensionImpl_ == nullptr) {
55         LOG_W(BMS_TAG_QUERY, "bmsExtensionImpl_ is nullptr");
56         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
57     }
58     ErrCode res = bmsExtensionImpl_->QueryAbilityInfos(want, userId, abilityInfos);
59     if (res != ERR_OK) {
60         LOG_D(BMS_TAG_QUERY, "query ability infos failed due to error code %{public}d", res);
61         return res;
62     }
63     for_each(abilityInfos.begin(), abilityInfos.end(), [this](auto &info) {
64         // if labelId and label of abilityInfo is 0 or empty, replacing them by utilizing the corresponding
65         // elements of applicationInfo
66         ModifyLauncherAbilityInfo(info);
67     });
68     return ERR_OK;
69 }
70 
QueryAbilityInfos(const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos,bool isNewVersion) const71 ErrCode BmsExtensionClient::QueryAbilityInfos(const Want &want, int32_t flags, int32_t userId,
72     std::vector<AbilityInfo> &abilityInfos, bool isNewVersion) const
73 {
74     LOG_D(BMS_TAG_QUERY, "start to query abilityInfos from bms extension");
75     auto dataMgr = GetDataMgr();
76     if (dataMgr == nullptr) {
77         LOG_W(BMS_TAG_QUERY, "dataMgr is nullptr");
78         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
79     }
80     if (userId != Constants::ALL_USERID) {
81         int32_t requestUserId = dataMgr->GetUserId(userId);
82         if (requestUserId == Constants::INVALID_USERID) {
83             return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
84         }
85     }
86 
87     std::string bundleName = want.GetElement().GetBundleName();
88     InnerBundleInfo info;
89     if (!bundleName.empty() && dataMgr->QueryInnerBundleInfo(bundleName, info)) {
90         LOG_D(BMS_TAG_QUERY, "bundle %{public}s has been existed and does not need to find in bms extension",
91             bundleName.c_str());
92         return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
93     }
94 
95     if (bmsExtensionImpl_ == nullptr) {
96         LOG_W(BMS_TAG_QUERY, "bmsExtensionImpl_ is nullptr");
97         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
98     }
99     ErrCode res = bmsExtensionImpl_->QueryAbilityInfosWithFlag(want, flags, userId, abilityInfos, isNewVersion);
100     if (res != ERR_OK) {
101         LOG_D(BMS_TAG_QUERY, "query ability infos failed due to error code %{public}d", res);
102         return res;
103     }
104     if (abilityInfos.empty()) {
105         LOG_D(BMS_TAG_QUERY, "no ability info can be found from bms extension");
106         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
107     }
108     return ERR_OK;
109 }
110 
BatchQueryAbilityInfos(const std::vector<Want> & wants,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos,bool isNewVersion) const111 ErrCode BmsExtensionClient::BatchQueryAbilityInfos(const std::vector<Want> &wants, int32_t flags, int32_t userId,
112     std::vector<AbilityInfo> &abilityInfos, bool isNewVersion) const
113 {
114     APP_LOGD("start to query abilityInfos from bms extension");
115     auto dataMgr = GetDataMgr();
116     if (dataMgr == nullptr) {
117         APP_LOGW("dataMgr is nullptr");
118         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
119     }
120     if (userId != Constants::ALL_USERID) {
121         int32_t requestUserId = dataMgr->GetUserId(userId);
122         if (requestUserId == Constants::INVALID_USERID) {
123             return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
124         }
125     }
126 
127     for (size_t i = 0; i < wants.size(); i++) {
128         std::vector<AbilityInfo> tmpAbilityInfos;
129         std::string bundleName = wants[i].GetElement().GetBundleName();
130         InnerBundleInfo info;
131         if (!bundleName.empty() && dataMgr->QueryInnerBundleInfo(bundleName, info)) {
132             APP_LOGD("bundle %{public}s has been existed and does not need to find in bms extension",
133                 bundleName.c_str());
134             return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
135         }
136 
137         if (bmsExtensionImpl_ == nullptr) {
138             APP_LOGW("bmsExtensionImpl_ is nullptr");
139             return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
140         }
141         ErrCode res = bmsExtensionImpl_->QueryAbilityInfosWithFlag(wants[i], flags, userId, tmpAbilityInfos,
142             isNewVersion);
143         if (res != ERR_OK) {
144             APP_LOGD("query ability infos failed due to error code %{public}d", res);
145             return res;
146         }
147         abilityInfos.insert(abilityInfos.end(), tmpAbilityInfos.begin(), tmpAbilityInfos.end());
148     }
149 
150     if (abilityInfos.empty()) {
151         APP_LOGD("no ability info can be found from bms extension");
152         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
153     }
154     return ERR_OK;
155 }
156 
QueryAbilityInfo(const Want & want,int32_t flags,int32_t userId,AbilityInfo & abilityInfo,bool isNewVersion) const157 ErrCode BmsExtensionClient::QueryAbilityInfo(const Want &want, int32_t flags, int32_t userId,
158     AbilityInfo &abilityInfo, bool isNewVersion) const
159 {
160     LOG_D(BMS_TAG_QUERY, "start to query abilityInfo from bms extension");
161     std::vector<AbilityInfo> abilityInfos;
162     ErrCode res = QueryAbilityInfos(want, flags, userId, abilityInfos, isNewVersion);
163     if (res != ERR_OK) {
164         LOG_D(BMS_TAG_QUERY, "query ability info failed due to error code %{public}d", res);
165         return res;
166     }
167     if (abilityInfos.empty()) {
168         LOG_D(BMS_TAG_QUERY, "no ability info can be found from bms extension");
169         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
170     }
171 
172     abilityInfo = abilityInfos[0];
173     return ERR_OK;
174 }
175 
GetBundleInfos(int32_t flags,std::vector<BundleInfo> & bundleInfos,int32_t userId,bool isNewVersion) const176 ErrCode BmsExtensionClient::GetBundleInfos(
177     int32_t flags, std::vector<BundleInfo> &bundleInfos, int32_t userId, bool isNewVersion) const
178 {
179     LOG_D(BMS_TAG_QUERY, "start to query bundle infos from bms extension");
180     if (userId != Constants::ALL_USERID) {
181         auto dataMgr = GetDataMgr();
182         if (dataMgr == nullptr) {
183             LOG_W(BMS_TAG_QUERY, "dataMgr is nullptr");
184             return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
185         }
186         int32_t requestUserId = dataMgr->GetUserId(userId);
187         if (requestUserId == Constants::INVALID_USERID) {
188             return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
189         }
190     }
191     if (bmsExtensionImpl_ == nullptr) {
192         LOG_W(BMS_TAG_QUERY, "bmsExtensionImpl_ is nullptr");
193         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
194     }
195     ErrCode res = bmsExtensionImpl_->GetBundleInfos(flags, bundleInfos, userId, isNewVersion);
196     if (res != ERR_OK) {
197         LOG_D(BMS_TAG_QUERY, "query bundle infos failed due to error code %{public}d", res);
198         return res;
199     }
200 
201     return ERR_OK;
202 }
203 
GetBundleInfo(const std::string & bundleName,int32_t flags,BundleInfo & bundleInfo,int32_t userId,bool isNewVersion) const204 ErrCode BmsExtensionClient::GetBundleInfo(const std::string &bundleName, int32_t flags,
205     BundleInfo &bundleInfo, int32_t userId, bool isNewVersion) const
206 {
207     LOG_D(BMS_TAG_QUERY, "start to query bundle info from bms extension");
208     auto dataMgr = GetDataMgr();
209     if (dataMgr == nullptr) {
210         LOG_W(BMS_TAG_QUERY, "dataMgr is nullptr");
211         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
212     }
213     if (userId != Constants::ALL_USERID) {
214         int32_t requestUserId = dataMgr->GetUserId(userId);
215         if (requestUserId == Constants::INVALID_USERID) {
216             return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
217         }
218     }
219     InnerBundleInfo info;
220     if (dataMgr->QueryInnerBundleInfo(bundleName, info)) {
221         LOG_D(BMS_TAG_QUERY, "bundle %{public}s has been existed and does not need to find in bms extension",
222             bundleName.c_str());
223         return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
224     }
225 
226     if (bmsExtensionImpl_ == nullptr) {
227         LOG_W(BMS_TAG_QUERY, "bmsExtensionImpl_ is nullptr");
228         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
229     }
230     ErrCode res = bmsExtensionImpl_->GetBundleInfo(bundleName, flags, userId, bundleInfo, isNewVersion);
231     if (res != ERR_OK) {
232         LOG_D(BMS_TAG_QUERY, "query bundle info failed due to error code %{public}d", res);
233         return res;
234     }
235 
236     return ERR_OK;
237 }
238 
BatchGetBundleInfo(const std::vector<std::string> & bundleNames,int32_t flags,std::vector<BundleInfo> & bundleInfos,int32_t userId,bool isNewVersion) const239 ErrCode BmsExtensionClient::BatchGetBundleInfo(const std::vector<std::string> &bundleNames, int32_t flags,
240     std::vector<BundleInfo> &bundleInfos, int32_t userId, bool isNewVersion) const
241 {
242     APP_LOGD("start to batch query bundle info from bms extension");
243     auto dataMgr = GetDataMgr();
244     if (dataMgr == nullptr) {
245         APP_LOGW("dataMgr is nullptr");
246         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
247     }
248     if (userId != Constants::ALL_USERID) {
249         int32_t requestUserId = dataMgr->GetUserId(userId);
250         if (requestUserId == Constants::INVALID_USERID) {
251             return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
252         }
253     }
254     if (bmsExtensionImpl_ == nullptr) {
255         APP_LOGW("bmsExtensionImpl_ is nullptr");
256         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
257     }
258     for (const auto &bundleName :bundleNames) {
259         if (dataMgr->IsBundleExist(bundleName)) {
260             continue;
261         }
262         BundleInfo bundleInfo;
263         ErrCode ret = bmsExtensionImpl_->GetBundleInfo(bundleName, flags, userId, bundleInfo, isNewVersion);
264         if (ret != ERR_OK) {
265             continue;
266         }
267         bundleInfos.push_back(bundleInfo);
268     }
269 
270     return ERR_OK;
271 }
272 
ImplicitQueryAbilityInfos(const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos,bool isNewVersion) const273 ErrCode BmsExtensionClient::ImplicitQueryAbilityInfos(
274     const Want &want, int32_t flags, int32_t userId, std::vector<AbilityInfo> &abilityInfos, bool isNewVersion) const
275 {
276     LOG_D(BMS_TAG_QUERY, "start to implicitly query ability info from bms extension");
277     if (userId != Constants::ALL_USERID) {
278         auto dataMgr = GetDataMgr();
279         if (dataMgr == nullptr) {
280             LOG_W(BMS_TAG_QUERY, "dataMgr is nullptr");
281             return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
282         }
283         int32_t requestUserId = dataMgr->GetUserId(userId);
284         if (requestUserId == Constants::INVALID_USERID) {
285             return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
286         }
287     }
288 
289     ElementName element = want.GetElement();
290     std::string bundleName = element.GetBundleName();
291     std::string abilityName = element.GetAbilityName();
292     // does not support explicit query
293     if (!bundleName.empty() && !abilityName.empty()) {
294         LOG_W(BMS_TAG_QUERY, "implicit query failed bundleName:%{public}s, abilityName:%{public}s not empty",
295             bundleName.c_str(), abilityName.c_str());
296         return ERR_BUNDLE_MANAGER_PARAM_ERROR;
297     }
298     ErrCode res = QueryAbilityInfos(want, flags, userId, abilityInfos, isNewVersion);
299     if (res != ERR_OK) {
300         LOG_E(BMS_TAG_QUERY, "query ability info failed error code %{public}d", res);
301         return res;
302     }
303     if (abilityInfos.empty()) {
304         LOG_E(BMS_TAG_QUERY, "no ability info can be found from bms extension");
305         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
306     }
307 
308     return ERR_OK;
309 }
310 
GetBundleStats(const std::string & bundleName,int32_t userId,std::vector<int64_t> & bundleStats)311 ErrCode BmsExtensionClient::GetBundleStats(
312     const std::string &bundleName, int32_t userId, std::vector<int64_t> &bundleStats)
313 {
314     if (bmsExtensionImpl_ == nullptr) {
315         APP_LOGW("bmsExtensionImpl_ is null");
316         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
317     }
318     return bmsExtensionImpl_->GetBundleStats(bundleName, userId, bundleStats);
319 }
ClearData(const std::string & bundleName,int32_t userId)320 ErrCode BmsExtensionClient::ClearData(const std::string &bundleName, int32_t userId)
321 {
322     if (bmsExtensionImpl_ == nullptr) {
323         APP_LOGW("bmsExtensionImpl_ is null");
324         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
325     }
326     return bmsExtensionImpl_->ClearData(bundleName, userId);
327 }
ClearCache(const std::string & bundleName,sptr<IRemoteObject> callback,int32_t userId)328 ErrCode BmsExtensionClient::ClearCache(const std::string &bundleName, sptr<IRemoteObject> callback, int32_t userId)
329 {
330     if (bmsExtensionImpl_ == nullptr) {
331         APP_LOGW("bmsExtensionImpl_ is null");
332         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
333     }
334     return bmsExtensionImpl_->ClearCache(bundleName, callback, userId);
335 }
GetUidByBundleName(const std::string & bundleName,int32_t userId,int32_t & uid)336 ErrCode BmsExtensionClient::GetUidByBundleName(const std::string &bundleName, int32_t userId, int32_t &uid)
337 {
338     if (bmsExtensionImpl_ == nullptr) {
339         APP_LOGW("bmsExtensionImpl_ is null");
340         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
341     }
342     return bmsExtensionImpl_->GetUidByBundleName(bundleName, userId, uid);
343 }
GetBundleNameByUid(int32_t uid,std::string & bundleName)344 ErrCode BmsExtensionClient::GetBundleNameByUid(int32_t uid, std::string &bundleName)
345 {
346     if (bmsExtensionImpl_ == nullptr) {
347         APP_LOGW("bmsExtensionImpl_ is null");
348         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
349     }
350     return bmsExtensionImpl_->GetBundleNameByUid(uid, bundleName);
351 }
352 
AddResourceInfoByBundleName(const std::string & bundleName,const int32_t userId)353 ErrCode BmsExtensionClient::AddResourceInfoByBundleName(const std::string &bundleName, const int32_t userId)
354 {
355     if (bmsExtensionImpl_ == nullptr) {
356         APP_LOGW("bmsExtensionImpl_ is null");
357         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
358     }
359     return bmsExtensionImpl_->AddResourceInfoByBundleName(bundleName, userId);
360 }
361 
AddResourceInfoByAbility(const std::string & bundleName,const std::string & moduleName,const std::string & abilityName,const int32_t userId)362 ErrCode BmsExtensionClient::AddResourceInfoByAbility(const std::string &bundleName, const std::string &moduleName,
363     const std::string &abilityName, const int32_t userId)
364 {
365     if (bmsExtensionImpl_ == nullptr) {
366         APP_LOGW("bmsExtensionImpl_ is null");
367         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
368     }
369     return bmsExtensionImpl_->AddResourceInfoByAbility(bundleName, moduleName, abilityName, userId);
370 }
371 
DeleteResourceInfo(const std::string & key)372 ErrCode BmsExtensionClient::DeleteResourceInfo(const std::string &key)
373 {
374     if (bmsExtensionImpl_ == nullptr) {
375         APP_LOGW("bmsExtensionImpl_ is null");
376         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
377     }
378     return bmsExtensionImpl_->DeleteResourceInfo(key);
379 }
380 
OptimizeDisposedPredicates(const std::string & callingName,const std::string & appId,int32_t userId,int32_t appIndex,NativeRdb::AbsRdbPredicates & absRdbPredicates)381 ErrCode BmsExtensionClient::OptimizeDisposedPredicates(const std::string &callingName, const std::string &appId,
382     int32_t userId, int32_t appIndex, NativeRdb::AbsRdbPredicates &absRdbPredicates)
383 {
384     if (bmsExtensionImpl_ == nullptr) {
385         APP_LOGW("bmsExtensionImpl_ is null");
386         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
387     }
388     return bmsExtensionImpl_->OptimizeDisposedPredicates(callingName, appId, userId, appIndex, absRdbPredicates);
389 }
390 
ModifyLauncherAbilityInfo(AbilityInfo & abilityInfo) const391 void BmsExtensionClient::ModifyLauncherAbilityInfo(AbilityInfo &abilityInfo) const
392 {
393     if (abilityInfo.labelId == 0) {
394         abilityInfo.labelId = abilityInfo.applicationInfo.labelId;
395     }
396 
397     if (abilityInfo.label.empty()) {
398         abilityInfo.label = abilityInfo.applicationInfo.label;
399     }
400 
401     if (abilityInfo.iconId == 0) {
402         abilityInfo.iconId = abilityInfo.applicationInfo.iconId;
403     }
404 }
405 
GetBundleResourceInfo(const std::string & bundleName,const uint32_t flags,BundleResourceInfo & bundleResourceInfo,const int32_t appIndex)406 ErrCode BmsExtensionClient::GetBundleResourceInfo(const std::string &bundleName, const uint32_t flags,
407     BundleResourceInfo &bundleResourceInfo, const int32_t appIndex)
408 {
409     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
410     if (bmsExtensionImpl_ == nullptr) {
411         APP_LOGW("bmsExtensionImpl_ is null");
412         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
413     }
414     return bmsExtensionImpl_->GetBundleResourceInfo(bundleName, flags, bundleResourceInfo, appIndex);
415 }
416 
GetLauncherAbilityResourceInfo(const std::string & bundleName,const uint32_t flags,std::vector<LauncherAbilityResourceInfo> & launcherAbilityResourceInfo,const int32_t appIndex)417 ErrCode BmsExtensionClient::GetLauncherAbilityResourceInfo(const std::string &bundleName, const uint32_t flags,
418     std::vector<LauncherAbilityResourceInfo> &launcherAbilityResourceInfo, const int32_t appIndex)
419 {
420     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
421     if (bmsExtensionImpl_ == nullptr) {
422         APP_LOGW("bmsExtensionImpl_ is null");
423         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
424     }
425     return bmsExtensionImpl_->GetLauncherAbilityResourceInfo(bundleName, flags, launcherAbilityResourceInfo, appIndex);
426 }
427 
GetAllBundleResourceInfo(const uint32_t flags,std::vector<BundleResourceInfo> & bundleResourceInfos)428 ErrCode BmsExtensionClient::GetAllBundleResourceInfo(const uint32_t flags,
429     std::vector<BundleResourceInfo> &bundleResourceInfos)
430 {
431     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
432     if (bmsExtensionImpl_ == nullptr) {
433         APP_LOGW("bmsExtensionImpl_ is null");
434         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
435     }
436     return bmsExtensionImpl_->GetAllBundleResourceInfo(flags, bundleResourceInfos);
437 }
438 
GetAllLauncherAbilityResourceInfo(const uint32_t flags,std::vector<LauncherAbilityResourceInfo> & launcherAbilityResourceInfos)439 ErrCode BmsExtensionClient::GetAllLauncherAbilityResourceInfo(const uint32_t flags,
440     std::vector<LauncherAbilityResourceInfo> &launcherAbilityResourceInfos)
441 {
442     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
443     if (bmsExtensionImpl_ == nullptr) {
444         APP_LOGW("bmsExtensionImpl_ is null");
445         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
446     }
447     return bmsExtensionImpl_->GetAllLauncherAbilityResourceInfo(flags, launcherAbilityResourceInfos);
448 }
449 
GetDataMgr() const450 const std::shared_ptr<BundleDataMgr> BmsExtensionClient::GetDataMgr() const
451 {
452     return DelayedSingleton<BundleMgrService>::GetInstance()->GetDataMgr();
453 }
454 } // AppExecFwk
455 } // OHOS
456