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 <dlfcn.h>
17 
18 #include "app_log_wrapper.h"
19 #include "app_log_tag_wrapper.h"
20 #include "bms_extension_data_mgr.h"
21 #include "bms_extension_profile.h"
22 #include "bundle_mgr_ext_register.h"
23 #include "parameter.h"
24 
25 namespace OHOS {
26 namespace AppExecFwk {
27 BmsExtension BmsExtensionDataMgr::bmsExtension_;
28 void *BmsExtensionDataMgr::handler_ = nullptr;
29 namespace {
30 static std::mutex stateMutex;
31 const std::string BMS_EXTENSION_PATH = "/system/etc/app/bms-extensions.json";
32 const uint32_t API_VERSION_BASE = 1000;
33 }
34 
BmsExtensionDataMgr()35 BmsExtensionDataMgr::BmsExtensionDataMgr()
36 {
37 }
38 
Init()39 ErrCode BmsExtensionDataMgr::Init()
40 {
41     std::lock_guard<std::mutex> stateLock(stateMutex);
42     if (bmsExtension_.bmsExtensionBundleMgr.extensionName.empty() || !handler_) {
43         BmsExtensionProfile bmsExtensionProfile;
44         auto res = bmsExtensionProfile.ParseBmsExtension(BMS_EXTENSION_PATH, bmsExtension_);
45         if (res != ERR_OK) {
46             APP_LOGW("ParseBmsExtension failed %{public}d", res);
47             return ERR_APPEXECFWK_PARSE_UNEXPECTED;
48         }
49         APP_LOGD("parse bms-extension.json success, which is: %{public}s", bmsExtension_.ToString().c_str());
50         if (!OpenHandler()) {
51             APP_LOGW("dlopen bms-extension so failed");
52             return ERR_APPEXECFWK_INSTALL_INTERNAL_ERROR;
53         }
54     }
55     return ERR_OK;
56 }
57 
OpenHandler()58 bool BmsExtensionDataMgr::OpenHandler()
59 {
60     APP_LOGD("OpenHandler start");
61     auto handle = &handler_;
62     if (handle == nullptr) {
63         APP_LOGE("OpenHandler error handle is nullptr");
64         return false;
65     }
66     auto libPath = bmsExtension_.bmsExtensionBundleMgr.libPath.c_str();
67     auto lib64Path = bmsExtension_.bmsExtensionBundleMgr.lib64Path.c_str();
68     *handle = dlopen(lib64Path, RTLD_NOW | RTLD_GLOBAL);
69     if (*handle == nullptr) {
70         APP_LOGW("open %{public}s failed %{public}s", lib64Path, dlerror());
71         *handle = dlopen(libPath, RTLD_NOW | RTLD_GLOBAL);
72     }
73     if (*handle == nullptr) {
74         APP_LOGE("open %{public}s failed %{public}s", libPath, dlerror());
75         return false;
76     }
77     APP_LOGD("OpenHandler end");
78     return true;
79 }
80 
CheckApiInfo(const BundleInfo & bundleInfo,uint32_t sdkVersion)81 bool BmsExtensionDataMgr::CheckApiInfo(const BundleInfo &bundleInfo, uint32_t sdkVersion)
82 {
83     if ((Init() == ERR_OK) && handler_) {
84         auto bundleMgrExtPtr =
85             BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
86         if (bundleMgrExtPtr) {
87             return bundleMgrExtPtr->CheckApiInfo(bundleInfo);
88         }
89         APP_LOGE("create class: %{public}s failed", bmsExtension_.bmsExtensionBundleMgr.extensionName.c_str());
90         return false;
91     }
92     APP_LOGW("access bms-extension failed");
93     return CheckApiInfo(bundleInfo.compatibleVersion, sdkVersion);
94 }
95 
CheckApiInfo(uint32_t compatibleVersion,uint32_t sdkVersion)96 bool BmsExtensionDataMgr::CheckApiInfo(uint32_t compatibleVersion, uint32_t sdkVersion)
97 {
98     APP_LOGD("CheckApiInfo with compatibleVersion:%{public}d, sdkVersion:%{public}d", compatibleVersion, sdkVersion);
99     uint32_t compatibleVersionOHOS = compatibleVersion % API_VERSION_BASE;
100     return compatibleVersionOHOS <= sdkVersion;
101 }
102 
HapVerify(const std::string & filePath,Security::Verify::HapVerifyResult & hapVerifyResult)103 ErrCode BmsExtensionDataMgr::HapVerify(const std::string &filePath, Security::Verify::HapVerifyResult &hapVerifyResult)
104 {
105     if ((Init() == ERR_OK) && handler_) {
106         auto bundleMgrExtPtr =
107             BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
108         if (bundleMgrExtPtr == nullptr) {
109             APP_LOGW("bundleMgrExtPtr is nullptr");
110             return ERR_APPEXECFWK_INSTALL_INTERNAL_ERROR;
111         }
112         return bundleMgrExtPtr->HapVerify(filePath, hapVerifyResult);
113     }
114     APP_LOGW("access bms-extension failed");
115     return ERR_BUNDLEMANAGER_INSTALL_FAILED_SIGNATURE_EXTENSION_NOT_EXISTED;
116 }
117 
IsRdDevice()118 bool BmsExtensionDataMgr::IsRdDevice()
119 {
120     if ((Init() != ERR_OK) || handler_ == nullptr) {
121         APP_LOGW("link failed");
122         return false;
123     }
124     auto bundleMgrExtPtr =
125         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
126     if (bundleMgrExtPtr == nullptr) {
127         APP_LOGW("GetBundleMgrExt failed");
128         return false;
129     }
130     return bundleMgrExtPtr->IsRdDevice();
131 }
132 
QueryAbilityInfos(const Want & want,int32_t userId,std::vector<AbilityInfo> & abilityInfos)133 ErrCode BmsExtensionDataMgr::QueryAbilityInfos(const Want &want, int32_t userId,
134     std::vector<AbilityInfo> &abilityInfos)
135 {
136     if ((Init() == ERR_OK) && handler_) {
137         auto bundleMgrExtPtr =
138             BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
139         if (bundleMgrExtPtr == nullptr) {
140             LOG_W(BMS_TAG_QUERY, "bundleMgrExtPtr is nullptr");
141             return ERR_APPEXECFWK_INSTALL_INTERNAL_ERROR;
142         }
143         return bundleMgrExtPtr->QueryAbilityInfos(want, userId, abilityInfos);
144     }
145     LOG_W(BMS_TAG_QUERY, "access bms-extension failed");
146     return ERR_BUNDLE_MANAGER_INSTALL_FAILED_BUNDLE_EXTENSION_NOT_EXISTED;
147 }
148 
QueryAbilityInfosWithFlag(const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos,bool isNewVersion)149 ErrCode BmsExtensionDataMgr::QueryAbilityInfosWithFlag(const Want &want, int32_t flags, int32_t userId,
150     std::vector<AbilityInfo> &abilityInfos, bool isNewVersion)
151 {
152     if ((Init() == ERR_OK) && handler_) {
153         auto bundleMgrExtPtr =
154             BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
155         if (bundleMgrExtPtr == nullptr) {
156             LOG_W(BMS_TAG_QUERY, "bundleMgrExtPtr is nullptr");
157             return ERR_APPEXECFWK_INSTALL_INTERNAL_ERROR;
158         }
159         return bundleMgrExtPtr->QueryAbilityInfosWithFlag(want, flags, userId, abilityInfos, isNewVersion);
160     }
161     LOG_W(BMS_TAG_QUERY, "access bms-extension failed");
162     return ERR_BUNDLE_MANAGER_INSTALL_FAILED_BUNDLE_EXTENSION_NOT_EXISTED;
163 }
164 
GetBundleInfos(int32_t flags,std::vector<BundleInfo> & bundleInfos,int32_t userId,bool isNewVersion)165 ErrCode BmsExtensionDataMgr::GetBundleInfos(int32_t flags, std::vector<BundleInfo> &bundleInfos, int32_t userId,
166     bool isNewVersion)
167 {
168     if ((Init() == ERR_OK) && handler_) {
169         auto bundleMgrExtPtr =
170             BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
171         if (bundleMgrExtPtr == nullptr) {
172             LOG_W(BMS_TAG_QUERY, "bundleMgrExtPtr is nullptr");
173             return ERR_APPEXECFWK_INSTALL_INTERNAL_ERROR;
174         }
175         return bundleMgrExtPtr->GetBundleInfos(flags, bundleInfos, userId, isNewVersion);
176     }
177     LOG_W(BMS_TAG_QUERY, "access bms-extension failed");
178     return ERR_BUNDLE_MANAGER_INSTALL_FAILED_BUNDLE_EXTENSION_NOT_EXISTED;
179 }
180 
GetBundleInfo(const std::string & bundleName,int32_t flags,int32_t userId,BundleInfo & bundleInfo,bool isNewVersion)181 ErrCode BmsExtensionDataMgr::GetBundleInfo(const std::string &bundleName, int32_t flags, int32_t userId,
182     BundleInfo &bundleInfo, bool isNewVersion)
183 {
184     if ((Init() == ERR_OK) && handler_) {
185         auto bundleMgrExtPtr =
186             BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
187         if (bundleMgrExtPtr == nullptr) {
188             LOG_W(BMS_TAG_QUERY, "bundleMgrExtPtr is nullptr");
189             return ERR_APPEXECFWK_INSTALL_INTERNAL_ERROR;
190         }
191         return bundleMgrExtPtr->GetBundleInfo(bundleName, flags, userId, bundleInfo, isNewVersion);
192     }
193     LOG_W(BMS_TAG_QUERY, "access bms-extension failed");
194     return ERR_BUNDLE_MANAGER_INSTALL_FAILED_BUNDLE_EXTENSION_NOT_EXISTED;
195 }
196 
Uninstall(const std::string & bundleName)197 ErrCode BmsExtensionDataMgr::Uninstall(const std::string &bundleName)
198 {
199     if ((Init() == ERR_OK) && handler_) {
200         auto bundleMgrExtPtr =
201             BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
202         if (bundleMgrExtPtr == nullptr) {
203             APP_LOGW("bundleMgrExtPtr is nullptr");
204             return ERR_APPEXECFWK_INSTALL_INTERNAL_ERROR;
205         }
206         return bundleMgrExtPtr->Uninstall(bundleName);
207     }
208     APP_LOGW("access bms-extension failed");
209     return ERR_BUNDLE_MANAGER_INSTALL_FAILED_BUNDLE_EXTENSION_NOT_EXISTED;
210 }
211 
GetBundleStats(const std::string & bundleName,int32_t userId,std::vector<int64_t> & bundleStats)212 ErrCode BmsExtensionDataMgr::GetBundleStats(
213     const std::string &bundleName, int32_t userId, std::vector<int64_t> &bundleStats)
214 {
215     if ((Init() != ERR_OK) || handler_ == nullptr) {
216         APP_LOGW("link failed");
217         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
218     }
219     auto bundleMgrExtPtr =
220         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
221     if (bundleMgrExtPtr == nullptr) {
222         APP_LOGW("GetBundleMgrExt failed");
223         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
224     }
225     return bundleMgrExtPtr->GetBundleStats(bundleName, userId, bundleStats);
226 }
227 
ClearData(const std::string & bundleName,int32_t userId)228 ErrCode BmsExtensionDataMgr::ClearData(const std::string &bundleName, int32_t userId)
229 {
230     if ((Init() != ERR_OK) || handler_ == nullptr) {
231         APP_LOGW("link failed");
232         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
233     }
234     auto bundleMgrExtPtr =
235         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
236     if (bundleMgrExtPtr == nullptr) {
237         APP_LOGW("GetBundleMgrExt failed");
238         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
239     }
240     return bundleMgrExtPtr->ClearData(bundleName, userId);
241 }
242 
ClearCache(const std::string & bundleName,sptr<IRemoteObject> callback,int32_t userId)243 ErrCode BmsExtensionDataMgr::ClearCache(const std::string &bundleName, sptr<IRemoteObject> callback, int32_t userId)
244 {
245     if ((Init() != ERR_OK) || handler_ == nullptr) {
246         APP_LOGW("link failed");
247         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
248     }
249     auto bundleMgrExtPtr =
250         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
251     if (bundleMgrExtPtr == nullptr) {
252         APP_LOGW("GetBundleMgrExt failed");
253         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
254     }
255     return bundleMgrExtPtr->ClearCache(bundleName, callback, userId);
256 }
257 
GetUidByBundleName(const std::string & bundleName,int32_t userId,int32_t & uid)258 ErrCode BmsExtensionDataMgr::GetUidByBundleName(const std::string &bundleName, int32_t userId, int32_t &uid)
259 {
260     if ((Init() != ERR_OK) || handler_ == nullptr) {
261         APP_LOGW("link failed");
262         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
263     }
264     auto bundleMgrExtPtr =
265         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
266     if (bundleMgrExtPtr == nullptr) {
267         APP_LOGW("GetBundleMgrExt failed");
268         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
269     }
270     return bundleMgrExtPtr->GetUidByBundleName(bundleName, userId, uid);
271 }
272 
GetBundleNameByUid(int32_t uid,std::string & bundleName)273 ErrCode BmsExtensionDataMgr::GetBundleNameByUid(int32_t uid, std::string &bundleName)
274 {
275     if ((Init() != ERR_OK) || handler_ == nullptr) {
276         APP_LOGW("link failed");
277         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
278     }
279     auto bundleMgrExtPtr =
280         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
281     if (bundleMgrExtPtr == nullptr) {
282         APP_LOGW("GetBundleMgrExt failed");
283         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
284     }
285     return bundleMgrExtPtr->GetBundleNameByUid(uid, bundleName);
286 }
287 
VerifyActivationLock(bool & res)288 ErrCode BmsExtensionDataMgr::VerifyActivationLock(bool &res)
289 {
290     if ((Init() != ERR_OK) || handler_ == nullptr) {
291         APP_LOGW("link failed");
292         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
293     }
294     auto bundleMgrExtPtr =
295         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
296     if (bundleMgrExtPtr == nullptr) {
297         APP_LOGW("GetBundleMgrExt failed");
298         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
299     }
300     return bundleMgrExtPtr->VerifyActivationLock(res);
301 }
302 
GetBackupUninstallList(int32_t userId,std::set<std::string> & uninstallBundles)303 ErrCode BmsExtensionDataMgr::GetBackupUninstallList(int32_t userId, std::set<std::string> &uninstallBundles)
304 {
305     if (Init() != ERR_OK || handler_ == nullptr) {
306         APP_LOGW("link failed");
307         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
308     }
309     auto bundleMgrExtPtr =
310         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
311     if (bundleMgrExtPtr == nullptr) {
312         APP_LOGW("GetBundleMgrExt failed");
313         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
314     }
315     return bundleMgrExtPtr->GetBackupUninstallList(userId, uninstallBundles);
316 }
317 
ClearBackupUninstallFile(int32_t userId)318 ErrCode BmsExtensionDataMgr::ClearBackupUninstallFile(int32_t userId)
319 {
320     if (Init() != ERR_OK || handler_ == nullptr) {
321         APP_LOGW("link failed");
322         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
323     }
324     auto bundleMgrExtPtr =
325         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
326     if (bundleMgrExtPtr == nullptr) {
327         APP_LOGW("GetBundleMgrExt failed");
328         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
329     }
330     return bundleMgrExtPtr->ClearBackupUninstallFile(userId);
331 }
332 
IsAppInBlocklist(const std::string & bundleName,const int32_t userId)333 bool BmsExtensionDataMgr::IsAppInBlocklist(const std::string &bundleName, const int32_t userId)
334 {
335     if ((Init() != ERR_OK) || handler_ == nullptr) {
336         APP_LOGW("link failed");
337         return false;
338     }
339     auto bundleMgrExtPtr =
340         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
341     if (bundleMgrExtPtr == nullptr) {
342         APP_LOGW("GetBundleMgrExt failed");
343         return false;
344     }
345     return bundleMgrExtPtr->IsAppInBlocklist(bundleName, userId);
346 }
347 
CheckWhetherCanBeUninstalled(const std::string & bundleName)348 bool BmsExtensionDataMgr::CheckWhetherCanBeUninstalled(const std::string &bundleName)
349 {
350     if ((Init() != ERR_OK) || handler_ == nullptr) {
351         APP_LOGW("link failed");
352         return true;
353     }
354     auto bundleMgrExtPtr =
355         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
356     if (bundleMgrExtPtr == nullptr) {
357         APP_LOGW("GetBundleMgrExt failed");
358         return true;
359     }
360     return bundleMgrExtPtr->CheckWhetherCanBeUninstalled(bundleName);
361 }
362 
AddResourceInfoByBundleName(const std::string & bundleName,const int32_t userId)363 ErrCode BmsExtensionDataMgr::AddResourceInfoByBundleName(const std::string &bundleName, const int32_t userId)
364 {
365     if (Init() != ERR_OK || handler_ == nullptr) {
366         APP_LOGW("link failed");
367         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
368     }
369     auto bundleMgrExtPtr =
370         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
371     if (bundleMgrExtPtr == nullptr) {
372         APP_LOGW("GetBundleMgrExt failed");
373         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
374     }
375     ErrCode ret = bundleMgrExtPtr->AddResourceInfoByBundleName(bundleName, userId);
376     APP_LOGD("call bundle mgr ext return %{public}d by bundleName:%{public}s userId:%{private}d",
377         ret, bundleName.c_str(), userId);
378     return ret;
379 }
380 
AddResourceInfoByAbility(const std::string & bundleName,const std::string & moduleName,const std::string & abilityName,const int32_t userId)381 ErrCode BmsExtensionDataMgr::AddResourceInfoByAbility(const std::string &bundleName, const std::string &moduleName,
382     const std::string &abilityName, const int32_t userId)
383 {
384     if (Init() != ERR_OK || handler_ == nullptr) {
385         APP_LOGW("link failed");
386         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
387     }
388     auto bundleMgrExtPtr =
389         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
390     if (bundleMgrExtPtr == nullptr) {
391         APP_LOGW("GetBundleMgrExt failed");
392         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
393     }
394     ErrCode ret = bundleMgrExtPtr->AddResourceInfoByAbility(bundleName, moduleName, abilityName, userId);
395     APP_LOGD("call bundle mgr ext return %{public}d by bundleName:%{public}s moduleName:%{public}s \
396         abilityName:%{public}s userId:%{private}d",
397         ret, bundleName.c_str(), moduleName.c_str(), abilityName.c_str(), userId);
398     return ret;
399 }
400 
DeleteResourceInfo(const std::string & key)401 ErrCode BmsExtensionDataMgr::DeleteResourceInfo(const std::string &key)
402 {
403     if (Init() != ERR_OK || handler_ == nullptr) {
404         APP_LOGW("link failed");
405         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
406     }
407     auto bundleMgrExtPtr =
408         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
409     if (bundleMgrExtPtr == nullptr) {
410         APP_LOGW("GetBundleMgrExt failed");
411         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
412     }
413     ErrCode ret = bundleMgrExtPtr->DeleteResourceInfo(key);
414     APP_LOGD("call bundle mgr ext return %{public}d by key:%{private}s", ret, key.c_str());
415     return ret;
416 }
417 
OptimizeDisposedPredicates(const std::string & callingName,const std::string & appId,int32_t userId,int32_t appIndex,NativeRdb::AbsRdbPredicates & absRdbPredicates)418 ErrCode BmsExtensionDataMgr::OptimizeDisposedPredicates(const std::string &callingName, const std::string &appId,
419     int32_t userId, int32_t appIndex, NativeRdb::AbsRdbPredicates &absRdbPredicates)
420 {
421     if (Init() != ERR_OK || handler_ == nullptr) {
422         APP_LOGW("link failed");
423         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
424     }
425     auto bundleMgrExtPtr =
426         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
427     if (bundleMgrExtPtr == nullptr) {
428         APP_LOGW("GetBundleMgrExt failed");
429         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
430     }
431     ErrCode ret = bundleMgrExtPtr->OptimizeDisposedPredicates(callingName, appId, userId, appIndex, absRdbPredicates);
432     APP_LOGD("call bundle mgr ext OptimizeDisposedPredicates, return %{public}d, result:%{private}s",
433         ret, absRdbPredicates.ToString().c_str());
434     return ret;
435 }
436 
GetBundleResourceInfo(const std::string & bundleName,const uint32_t flags,BundleResourceInfo & bundleResourceInfo,const int32_t appIndex)437 ErrCode BmsExtensionDataMgr::GetBundleResourceInfo(const std::string &bundleName, const uint32_t flags,
438     BundleResourceInfo &bundleResourceInfo, const int32_t appIndex)
439 {
440     if (Init() != ERR_OK || handler_ == nullptr) {
441         APP_LOGW("link failed");
442         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
443     }
444     auto bundleMgrExtPtr =
445         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
446     if (bundleMgrExtPtr == nullptr) {
447         APP_LOGW("GetBundleMgrExt failed");
448         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
449     }
450     ErrCode ret = bundleMgrExtPtr->GetBundleResourceInfo(bundleName, flags, bundleResourceInfo, appIndex);
451     APP_LOGD("call bundle mgr ext GetBundleResourceInfo, return %{public}d, bundleName:%{public}s",
452         ret, bundleName.c_str());
453     return ret;
454 }
455 
GetLauncherAbilityResourceInfo(const std::string & bundleName,const uint32_t flags,std::vector<LauncherAbilityResourceInfo> & launcherAbilityResourceInfo,const int32_t appIndex)456 ErrCode BmsExtensionDataMgr::GetLauncherAbilityResourceInfo(const std::string &bundleName, const uint32_t flags,
457     std::vector<LauncherAbilityResourceInfo> &launcherAbilityResourceInfo, const int32_t appIndex)
458 {
459     if (Init() != ERR_OK || handler_ == nullptr) {
460         APP_LOGW("link failed");
461         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
462     }
463     auto bundleMgrExtPtr =
464         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
465     if (bundleMgrExtPtr == nullptr) {
466         APP_LOGW("GetBundleMgrExt failed");
467         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
468     }
469     ErrCode ret =
470         bundleMgrExtPtr->GetLauncherAbilityResourceInfo(bundleName, flags, launcherAbilityResourceInfo, appIndex);
471     APP_LOGD("call bundle mgr ext GetLauncherAbilityResourceInfo, return %{public}d, bundleName:%{public}s",
472         ret, bundleName.c_str());
473     return ret;
474 }
475 
GetAllBundleResourceInfo(const uint32_t flags,std::vector<BundleResourceInfo> & bundleResourceInfos)476 ErrCode BmsExtensionDataMgr::GetAllBundleResourceInfo(const uint32_t flags,
477     std::vector<BundleResourceInfo> &bundleResourceInfos)
478 {
479     if (Init() != ERR_OK || handler_ == nullptr) {
480         APP_LOGW("link failed");
481         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
482     }
483     auto bundleMgrExtPtr =
484         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
485     if (bundleMgrExtPtr == nullptr) {
486         APP_LOGW("GetBundleMgrExt failed");
487         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
488     }
489     ErrCode ret = bundleMgrExtPtr->GetAllBundleResourceInfo(flags, bundleResourceInfos);
490     APP_LOGD("call bundle mgr ext GetAllBundleResourceInfo, return %{public}d", ret);
491     return ret;
492 }
493 
GetAllLauncherAbilityResourceInfo(const uint32_t flags,std::vector<LauncherAbilityResourceInfo> & launcherAbilityResourceInfos)494 ErrCode BmsExtensionDataMgr::GetAllLauncherAbilityResourceInfo(const uint32_t flags,
495     std::vector<LauncherAbilityResourceInfo> &launcherAbilityResourceInfos)
496 {
497     if (Init() != ERR_OK || handler_ == nullptr) {
498         APP_LOGW("link failed");
499         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
500     }
501     auto bundleMgrExtPtr =
502         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
503     if (bundleMgrExtPtr == nullptr) {
504         APP_LOGW("GetBundleMgrExt failed");
505         return ERR_BUNDLE_MANAGER_EXTENSION_INTERNAL_ERR;
506     }
507     ErrCode ret = bundleMgrExtPtr->GetAllLauncherAbilityResourceInfo(flags, launcherAbilityResourceInfos);
508     APP_LOGD("call bundle mgr ext GetAllLauncherAbilityResourceInfo, return %{public}d", ret);
509     return ret;
510 }
511 
DetermineCloneNum(const std::string & bundleName,const std::string & appIdentifier,int32_t & cloneNum)512 bool BmsExtensionDataMgr::DetermineCloneNum(
513     const std::string &bundleName, const std::string &appIdentifier, int32_t &cloneNum)
514 {
515     if (Init() != ERR_OK || handler_ == nullptr) {
516         APP_LOGW("link failed");
517         return false;
518     }
519     if (bundleName.empty()) {
520         APP_LOGW("bundleName empty");
521         return false;
522     }
523     auto bundleMgrExtPtr =
524         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
525     if (bundleMgrExtPtr == nullptr) {
526         APP_LOGW("GetBundleMgrExt failed");
527         return false;
528     }
529     return bundleMgrExtPtr->DetermineCloneNum(bundleName, appIdentifier, cloneNum);
530 }
531 
CheckBundleNameAndStratAbility(const std::string & bundleName,const std::string & appIdentifier)532 void BmsExtensionDataMgr::CheckBundleNameAndStratAbility(const std::string &bundleName,
533     const std::string &appIdentifier)
534 {
535     if (Init() != ERR_OK || handler_ == nullptr) {
536         APP_LOGW("link failed");
537         return;
538     }
539     if (bundleName.empty()) {
540         APP_LOGW("bundleName empty");
541         return;
542     }
543     auto bundleMgrExtPtr =
544         BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
545     if (bundleMgrExtPtr == nullptr) {
546         APP_LOGW("GetBundleMgrExt failed");
547         return;
548     }
549     bundleMgrExtPtr->CheckBundleNameAndStratAbility(bundleName, appIdentifier);
550 }
551 
GetCompatibleDeviceType(const std::string & bundleName)552 std::string BmsExtensionDataMgr::GetCompatibleDeviceType(const std::string &bundleName)
553 {
554     if ((Init() == ERR_OK) && handler_) {
555         auto bundleMgrExtPtr =
556             BundleMgrExtRegister::GetInstance().GetBundleMgrExt(bmsExtension_.bmsExtensionBundleMgr.extensionName);
557         if (bundleMgrExtPtr) {
558             return bundleMgrExtPtr->GetCompatibleDeviceType(bundleName);
559         }
560         APP_LOGE("create class: %{public}s failed", bmsExtension_.bmsExtensionBundleMgr.extensionName.c_str());
561         return GetDeviceType();
562     }
563     APP_LOGW("access bms-extension failed");
564     return GetDeviceType();
565 }
566 } // AppExecFwk
567 } // OHOS
568