1 /*
2 * Copyright (c) 2023-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 "bundle_mgr_helper.h"
17
18 #include "bundle_mgr_service_death_recipient.h"
19 #include "global_constant.h"
20 #include "hilog_tag_wrapper.h"
21 #include "hitrace_meter.h"
22 #include "iservice_registry.h"
23 #include "system_ability_definition.h"
24
25 namespace OHOS {
26 namespace AppExecFwk {
BundleMgrHelper()27 BundleMgrHelper::BundleMgrHelper() {}
28
~BundleMgrHelper()29 BundleMgrHelper::~BundleMgrHelper()
30 {
31 if (bundleMgr_ != nullptr && bundleMgr_->AsObject() != nullptr && deathRecipient_ != nullptr) {
32 bundleMgr_->AsObject()->RemoveDeathRecipient(deathRecipient_);
33 }
34 }
35
PreConnect()36 void BundleMgrHelper::PreConnect()
37 {
38 Connect();
39 }
40
GetNameForUid(const int32_t uid,std::string & name)41 ErrCode BundleMgrHelper::GetNameForUid(const int32_t uid, std::string &name)
42 {
43 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
44 auto bundleMgr = Connect();
45 if (bundleMgr == nullptr) {
46 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect.");
47 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
48 }
49
50 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
51 return bundleMgr->GetNameForUid(uid, name);
52 }
53
GetNameAndIndexForUid(const int32_t uid,std::string & bundleName,int32_t & appIndex)54 ErrCode BundleMgrHelper::GetNameAndIndexForUid(const int32_t uid, std::string &bundleName, int32_t &appIndex)
55 {
56 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
57 auto bundleMgr = Connect();
58 if (bundleMgr == nullptr) {
59 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect.");
60 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
61 }
62
63 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
64 return bundleMgr->GetNameAndIndexForUid(uid, bundleName, appIndex);
65 }
66
GetBundleInfo(const std::string & bundleName,const BundleFlag flag,BundleInfo & bundleInfo,int32_t userId)67 bool BundleMgrHelper::GetBundleInfo(const std::string &bundleName, const BundleFlag flag, BundleInfo &bundleInfo,
68 int32_t userId)
69 {
70 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
71 auto bundleMgr = Connect();
72 if (bundleMgr == nullptr) {
73 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect.");
74 return false;
75 }
76
77 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
78 return bundleMgr->GetBundleInfo(bundleName, flag, bundleInfo, userId);
79 }
80
InstallSandboxApp(const std::string & bundleName,int32_t dlpType,int32_t userId,int32_t & appIndex)81 ErrCode BundleMgrHelper::InstallSandboxApp(const std::string &bundleName, int32_t dlpType, int32_t userId,
82 int32_t &appIndex)
83 {
84 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
85 if (bundleName.empty()) {
86 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "The bundleName is empty.");
87 return ERR_APPEXECFWK_SANDBOX_INSTALL_PARAM_ERROR;
88 }
89 auto bundleInstaller = ConnectBundleInstaller();
90 if (bundleInstaller == nullptr) {
91 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect.");
92 return ERR_APPEXECFWK_SANDBOX_INSTALL_INTERNAL_ERROR;
93 }
94
95 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
96 return bundleInstaller->InstallSandboxApp(bundleName, dlpType, userId, appIndex);
97 }
98
UninstallSandboxApp(const std::string & bundleName,int32_t appIndex,int32_t userId)99 ErrCode BundleMgrHelper::UninstallSandboxApp(const std::string &bundleName, int32_t appIndex, int32_t userId)
100 {
101 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
102 if (bundleName.empty() || appIndex <= AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
103 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "The params are invalid.");
104 return ERR_APPEXECFWK_SANDBOX_INSTALL_PARAM_ERROR;
105 }
106 auto bundleInstaller = ConnectBundleInstaller();
107 if (bundleInstaller == nullptr) {
108 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect.");
109 return ERR_APPEXECFWK_SANDBOX_INSTALL_INTERNAL_ERROR;
110 }
111
112 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
113 return bundleInstaller->UninstallSandboxApp(bundleName, appIndex, userId);
114 }
115
GetUninstalledBundleInfo(const std::string bundleName,BundleInfo & bundleInfo)116 ErrCode BundleMgrHelper::GetUninstalledBundleInfo(const std::string bundleName, BundleInfo &bundleInfo)
117 {
118 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
119 auto bundleMgr = Connect();
120 if (bundleMgr == nullptr) {
121 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect.");
122 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
123 }
124
125 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
126 return bundleMgr->GetUninstalledBundleInfo(bundleName, bundleInfo);
127 }
128
GetSandboxBundleInfo(const std::string & bundleName,int32_t appIndex,int32_t userId,BundleInfo & info)129 ErrCode BundleMgrHelper::GetSandboxBundleInfo(
130 const std::string &bundleName, int32_t appIndex, int32_t userId, BundleInfo &info)
131 {
132 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
133 if (bundleName.empty() || appIndex <= AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
134 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "The params are invalid.");
135 return ERR_APPEXECFWK_SANDBOX_INSTALL_PARAM_ERROR;
136 }
137 auto bundleMgr = Connect();
138 if (bundleMgr == nullptr) {
139 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
140 return ERR_APPEXECFWK_SANDBOX_INSTALL_INTERNAL_ERROR;
141 }
142
143 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
144 return bundleMgr->GetSandboxBundleInfo(bundleName, appIndex, userId, info);
145 }
146
GetSandboxAbilityInfo(const Want & want,int32_t appIndex,int32_t flags,int32_t userId,AbilityInfo & abilityInfo)147 ErrCode BundleMgrHelper::GetSandboxAbilityInfo(const Want &want, int32_t appIndex, int32_t flags, int32_t userId,
148 AbilityInfo &abilityInfo)
149 {
150 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
151 if (appIndex <= AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
152 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "The params are invalid");
153 return ERR_APPEXECFWK_SANDBOX_INSTALL_PARAM_ERROR;
154 }
155 auto bundleMgr = Connect();
156 if (bundleMgr == nullptr) {
157 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
158 return ERR_APPEXECFWK_SANDBOX_INSTALL_INTERNAL_ERROR;
159 }
160
161 AAFwk::Want newWant = want;
162 newWant.RemoveAllFd();
163
164 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
165 return bundleMgr->GetSandboxAbilityInfo(newWant, appIndex, flags, userId, abilityInfo);
166 }
167
GetSandboxExtAbilityInfos(const Want & want,int32_t appIndex,int32_t flags,int32_t userId,std::vector<ExtensionAbilityInfo> & extensionInfos)168 ErrCode BundleMgrHelper::GetSandboxExtAbilityInfos(const Want &want, int32_t appIndex, int32_t flags,
169 int32_t userId, std::vector<ExtensionAbilityInfo> &extensionInfos)
170 {
171 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
172 if (appIndex <= AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
173 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "The params are invalid");
174 return ERR_APPEXECFWK_SANDBOX_INSTALL_PARAM_ERROR;
175 }
176 auto bundleMgr = Connect();
177 if (bundleMgr == nullptr) {
178 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
179 return ERR_APPEXECFWK_SANDBOX_INSTALL_INTERNAL_ERROR;
180 }
181
182 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
183 return bundleMgr->GetSandboxExtAbilityInfos(want, appIndex, flags, userId, extensionInfos);
184 }
185
GetSandboxHapModuleInfo(const AbilityInfo & abilityInfo,int32_t appIndex,int32_t userId,HapModuleInfo & hapModuleInfo)186 ErrCode BundleMgrHelper::GetSandboxHapModuleInfo(const AbilityInfo &abilityInfo, int32_t appIndex, int32_t userId,
187 HapModuleInfo &hapModuleInfo)
188 {
189 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
190 if (appIndex <= AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
191 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "The params are invalid");
192 return ERR_APPEXECFWK_SANDBOX_INSTALL_PARAM_ERROR;
193 }
194 auto bundleMgr = Connect();
195 if (bundleMgr == nullptr) {
196 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
197 return ERR_APPEXECFWK_SANDBOX_INSTALL_INTERNAL_ERROR;
198 }
199
200 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
201 return bundleMgr->GetSandboxHapModuleInfo(abilityInfo, appIndex, userId, hapModuleInfo);
202 }
203
GetAppIdByBundleName(const std::string & bundleName,const int32_t userId)204 std::string BundleMgrHelper::GetAppIdByBundleName(const std::string &bundleName, const int32_t userId)
205 {
206 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "GetAppIdByBundleName called");
207 auto bundleMgr = Connect();
208 if (bundleMgr == nullptr) {
209 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect.");
210 return "";
211 }
212
213 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
214 return bundleMgr->GetAppIdByBundleName(bundleName, userId);
215 }
216
Connect()217 sptr<IBundleMgr> BundleMgrHelper::Connect()
218 {
219 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
220 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
221 std::lock_guard<std::mutex> lock(mutex_);
222 if (bundleMgr_ == nullptr) {
223 sptr<ISystemAbilityManager> systemAbilityManager =
224 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
225 if (systemAbilityManager == nullptr) {
226 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to get system ability manager");
227 return nullptr;
228 }
229
230 sptr<IRemoteObject> remoteObject_ = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
231 if (remoteObject_ == nullptr || (bundleMgr_ = iface_cast<IBundleMgr>(remoteObject_)) == nullptr) {
232 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to get bundle mgr service remote object");
233 return nullptr;
234 }
235 std::weak_ptr<BundleMgrHelper> weakPtr = shared_from_this();
236 auto deathCallback = [weakPtr](const wptr<IRemoteObject>& object) {
237 auto sharedPtr = weakPtr.lock();
238 if (sharedPtr == nullptr) {
239 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Bundle helper instance is nullptr");
240 return;
241 }
242 sharedPtr->OnDeath();
243 };
244 deathRecipient_ = new (std::nothrow) BundleMgrServiceDeathRecipient(deathCallback);
245 if (deathRecipient_ == nullptr) {
246 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to create death recipient");
247 return nullptr;
248 }
249 if (bundleMgr_->AsObject() != nullptr) {
250 bundleMgr_->AsObject()->AddDeathRecipient(deathRecipient_);
251 }
252 }
253
254 return bundleMgr_;
255 }
256
ConnectBundleInstaller()257 sptr<IBundleInstaller> BundleMgrHelper::ConnectBundleInstaller()
258 {
259 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
260 {
261 std::lock_guard<std::mutex> lock(mutex_);
262 if (bundleInstaller_ != nullptr) {
263 return bundleInstaller_;
264 }
265 }
266
267 auto bundleMgr = Connect();
268 if (bundleMgr == nullptr) {
269 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
270 return nullptr;
271 }
272 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
273 std::lock_guard<std::mutex> lock(mutex_);
274 bundleInstaller_ = bundleMgr->GetBundleInstaller();
275 if ((bundleInstaller_ == nullptr) || (bundleInstaller_->AsObject() == nullptr)) {
276 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to get bundle installer proxy");
277 return nullptr;
278 }
279
280 return bundleInstaller_;
281 }
282
OnDeath()283 void BundleMgrHelper::OnDeath()
284 {
285 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
286 std::lock_guard<std::mutex> lock(mutex_);
287 if (bundleMgr_ == nullptr || bundleMgr_->AsObject() == nullptr) {
288 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "bundleMgr_ is nullptr");
289 return;
290 }
291 bundleMgr_->AsObject()->RemoveDeathRecipient(deathRecipient_);
292 bundleMgr_ = nullptr;
293 bundleInstaller_ = nullptr;
294 }
295
GetBundleInfo(const std::string & bundleName,int32_t flags,BundleInfo & bundleInfo,int32_t userId)296 bool BundleMgrHelper::GetBundleInfo(const std::string &bundleName, int32_t flags,
297 BundleInfo &bundleInfo, int32_t userId)
298 {
299 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
300 auto bundleMgr = Connect();
301 if (bundleMgr == nullptr) {
302 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
303 return false;
304 }
305
306 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
307 return bundleMgr->GetBundleInfo(bundleName, flags, bundleInfo, userId);
308 }
309
GetHapModuleInfo(const AbilityInfo & abilityInfo,HapModuleInfo & hapModuleInfo)310 bool BundleMgrHelper::GetHapModuleInfo(const AbilityInfo &abilityInfo, HapModuleInfo &hapModuleInfo)
311 {
312 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
313 auto bundleMgr = Connect();
314 if (bundleMgr == nullptr) {
315 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
316 return false;
317 }
318
319 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
320 return bundleMgr->GetHapModuleInfo(abilityInfo, hapModuleInfo);
321 }
322
GetAbilityLabel(const std::string & bundleName,const std::string & abilityName)323 std::string BundleMgrHelper::GetAbilityLabel(const std::string &bundleName, const std::string &abilityName)
324 {
325 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
326 auto bundleMgr = Connect();
327 if (bundleMgr == nullptr) {
328 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
329 return "";
330 }
331
332 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
333 return bundleMgr->GetAbilityLabel(bundleName, abilityName);
334 }
335
GetAppType(const std::string & bundleName)336 std::string BundleMgrHelper::GetAppType(const std::string &bundleName)
337 {
338 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
339 auto bundleMgr = Connect();
340 if (bundleMgr == nullptr) {
341 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
342 return "";
343 }
344
345 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
346 return bundleMgr->GetAppType(bundleName);
347 }
348
GetBaseSharedBundleInfos(const std::string & bundleName,std::vector<BaseSharedBundleInfo> & baseSharedBundleInfos,GetDependentBundleInfoFlag flag)349 ErrCode BundleMgrHelper::GetBaseSharedBundleInfos(
350 const std::string &bundleName, std::vector<BaseSharedBundleInfo> &baseSharedBundleInfos,
351 GetDependentBundleInfoFlag flag)
352 {
353 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
354 auto bundleMgr = Connect();
355 if (bundleMgr == nullptr) {
356 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
357 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
358 }
359
360 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
361 return bundleMgr->GetBaseSharedBundleInfos(bundleName, baseSharedBundleInfos, flag);
362 }
363
GetBundleInfoForSelf(int32_t flags,BundleInfo & bundleInfo)364 ErrCode BundleMgrHelper::GetBundleInfoForSelf(int32_t flags, BundleInfo &bundleInfo)
365 {
366 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
367 auto bundleMgr = Connect();
368 if (bundleMgr == nullptr) {
369 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
370 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
371 }
372
373 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
374 return bundleMgr->GetBundleInfoForSelf(flags, bundleInfo);
375 }
376
GetDependentBundleInfo(const std::string & sharedBundleName,BundleInfo & sharedBundleInfo,GetDependentBundleInfoFlag flag)377 ErrCode BundleMgrHelper::GetDependentBundleInfo(const std::string &sharedBundleName, BundleInfo &sharedBundleInfo,
378 GetDependentBundleInfoFlag flag)
379 {
380 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
381 auto bundleMgr = Connect();
382 if (bundleMgr == nullptr) {
383 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
384 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
385 }
386
387 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
388 return bundleMgr->GetDependentBundleInfo(sharedBundleName, sharedBundleInfo, flag);
389 }
390
GetGroupDir(const std::string & dataGroupId,std::string & dir)391 bool BundleMgrHelper::GetGroupDir(const std::string &dataGroupId, std::string &dir)
392 {
393 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
394 auto bundleMgr = Connect();
395 if (bundleMgr == nullptr) {
396 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
397 return false;
398 }
399
400 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
401 return bundleMgr->GetGroupDir(dataGroupId, dir);
402 }
403
GetOverlayManagerProxy()404 sptr<IOverlayManager> BundleMgrHelper::GetOverlayManagerProxy()
405 {
406 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
407 auto bundleMgr = Connect();
408 if (bundleMgr == nullptr) {
409 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
410 return nullptr;
411 }
412
413 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
414 return bundleMgr->GetOverlayManagerProxy();
415 }
416
QueryAbilityInfo(const Want & want,AbilityInfo & abilityInfo)417 bool BundleMgrHelper::QueryAbilityInfo(const Want &want, AbilityInfo &abilityInfo)
418 {
419 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
420 auto bundleMgr = Connect();
421 if (bundleMgr == nullptr) {
422 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
423 return false;
424 }
425
426 AAFwk::Want newWant = want;
427 newWant.RemoveAllFd();
428 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
429 return bundleMgr->QueryAbilityInfo(newWant, abilityInfo);
430 }
431
QueryAbilityInfo(const Want & want,int32_t flags,int32_t userId,AbilityInfo & abilityInfo)432 bool BundleMgrHelper::QueryAbilityInfo(const Want &want, int32_t flags, int32_t userId, AbilityInfo &abilityInfo)
433 {
434 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
435 auto bundleMgr = Connect();
436 if (bundleMgr == nullptr) {
437 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
438 return false;
439 }
440
441 AAFwk::Want newWant = want;
442 newWant.RemoveAllFd();
443 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
444 return bundleMgr->QueryAbilityInfo(newWant, flags, userId, abilityInfo);
445 }
446
GetBundleInfos(int32_t flags,std::vector<BundleInfo> & bundleInfos,int32_t userId)447 bool BundleMgrHelper::GetBundleInfos(int32_t flags, std::vector<BundleInfo> &bundleInfos, int32_t userId)
448 {
449 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
450 auto bundleMgr = Connect();
451 if (bundleMgr == nullptr) {
452 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
453 return false;
454 }
455
456 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
457 return bundleMgr->GetBundleInfos(flags, bundleInfos, userId);
458 }
459
GetBundleInfos(const BundleFlag flag,std::vector<BundleInfo> & bundleInfos,int32_t userId)460 bool BundleMgrHelper::GetBundleInfos(const BundleFlag flag, std::vector<BundleInfo> &bundleInfos, int32_t userId)
461 {
462 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
463 auto bundleMgr = Connect();
464 if (bundleMgr == nullptr) {
465 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
466 return false;
467 }
468
469 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
470 return bundleMgr->GetBundleInfos(flag, bundleInfos, userId);
471 }
472
GetQuickFixManagerProxy()473 sptr<IQuickFixManager> BundleMgrHelper::GetQuickFixManagerProxy()
474 {
475 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
476 auto bundleMgr = Connect();
477 if (bundleMgr == nullptr) {
478 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
479 return nullptr;
480 }
481
482 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
483 return bundleMgr->GetQuickFixManagerProxy();
484 }
485
ProcessPreload(const Want & want)486 bool BundleMgrHelper::ProcessPreload(const Want &want)
487 {
488 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
489 auto bundleMgr = Connect();
490 if (bundleMgr == nullptr) {
491 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
492 return false;
493 }
494
495 AAFwk::Want newWant = want;
496 newWant.RemoveAllFd();
497 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
498 return bundleMgr->ProcessPreload(newWant);
499 }
500
GetAppControlProxy()501 sptr<IAppControlMgr> BundleMgrHelper::GetAppControlProxy()
502 {
503 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
504 auto bundleMgr = Connect();
505 if (bundleMgr == nullptr) {
506 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
507 return nullptr;
508 }
509
510 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
511 return bundleMgr->GetAppControlProxy();
512 }
513
QueryExtensionAbilityInfos(const Want & want,const int32_t & flag,const int32_t & userId,std::vector<ExtensionAbilityInfo> & extensionInfos)514 bool BundleMgrHelper::QueryExtensionAbilityInfos(const Want &want, const int32_t &flag, const int32_t &userId,
515 std::vector<ExtensionAbilityInfo> &extensionInfos)
516 {
517 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
518 auto bundleMgr = Connect();
519 if (bundleMgr == nullptr) {
520 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
521 return false;
522 }
523
524 AAFwk::Want newWant = want;
525 newWant.RemoveAllFd();
526 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
527 return bundleMgr->QueryExtensionAbilityInfos(newWant, flag, userId, extensionInfos);
528 }
529
GetBundleInfoV9(const std::string & bundleName,int32_t flags,BundleInfo & bundleInfo,int32_t userId)530 ErrCode BundleMgrHelper::GetBundleInfoV9(
531 const std::string &bundleName, int32_t flags, BundleInfo &bundleInfo, int32_t userId)
532 {
533 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
534 auto bundleMgr = Connect();
535 if (bundleMgr == nullptr) {
536 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
537 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
538 }
539
540 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
541 return bundleMgr->GetBundleInfoV9(bundleName, flags, bundleInfo, userId);
542 }
543
GetApplicationInfo(const std::string & appName,const ApplicationFlag flag,const int32_t userId,ApplicationInfo & appInfo)544 bool BundleMgrHelper::GetApplicationInfo(
545 const std::string &appName, const ApplicationFlag flag, const int32_t userId, ApplicationInfo &appInfo)
546 {
547 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
548 auto bundleMgr = Connect();
549 if (bundleMgr == nullptr) {
550 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
551 return false;
552 }
553
554 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
555 return bundleMgr->GetApplicationInfo(appName, flag, userId, appInfo);
556 }
557
GetApplicationInfo(const std::string & appName,int32_t flags,int32_t userId,ApplicationInfo & appInfo)558 bool BundleMgrHelper::GetApplicationInfo(
559 const std::string &appName, int32_t flags, int32_t userId, ApplicationInfo &appInfo)
560 {
561 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
562 auto bundleMgr = Connect();
563 if (bundleMgr == nullptr) {
564 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
565 return false;
566 }
567
568 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
569 return bundleMgr->GetApplicationInfo(appName, flags, userId, appInfo);
570 }
571
GetApplicationInfoWithAppIndex(const std::string & appName,int32_t appIndex,int32_t userId,ApplicationInfo & appInfo)572 bool BundleMgrHelper::GetApplicationInfoWithAppIndex(
573 const std::string &appName, int32_t appIndex, int32_t userId, ApplicationInfo &appInfo)
574 {
575 TAG_LOGI(AAFwkTag::BUNDLEMGRHELPER, "appName: %{public}s, appIndex: %{public}d", appName.c_str(), appIndex);
576 if (appIndex < 0) {
577 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Invalid appIndex");
578 return false;
579 }
580 auto bundleMgr = Connect();
581 if (bundleMgr == nullptr) {
582 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
583 return false;
584 }
585
586 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
587 BundleInfo bundleInfo;
588 if (appIndex == 0) {
589 if (bundleMgr->GetApplicationInfo(appName, AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, userId, appInfo)) {
590 return true;
591 }
592 } else if (appIndex <= AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
593 if (bundleMgr->GetCloneBundleInfo(appName,
594 static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION),
595 appIndex, bundleInfo, userId) == ERR_OK) {
596 appInfo = bundleInfo.applicationInfo;
597 return true;
598 }
599 } else {
600 if (bundleMgr->GetSandboxBundleInfo(appName, appIndex, userId, bundleInfo) == ERR_OK) {
601 appInfo = bundleInfo.applicationInfo;
602 return true;
603 }
604 }
605 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "GetApplicationInfo failed");
606 return false;
607 }
608
UnregisterBundleEventCallback(const sptr<IBundleEventCallback> & bundleEventCallback)609 bool BundleMgrHelper::UnregisterBundleEventCallback(const sptr<IBundleEventCallback> &bundleEventCallback)
610 {
611 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
612 if (bundleEventCallback == nullptr) {
613 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "The bundleEventCallback is nullptr");
614 return false;
615 }
616
617 auto bundleMgr = Connect();
618 if (bundleMgr == nullptr) {
619 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
620 return false;
621 }
622
623 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
624 return bundleMgr->UnregisterBundleEventCallback(bundleEventCallback);
625 }
626
QueryExtensionAbilityInfoByUri(const std::string & uri,int32_t userId,ExtensionAbilityInfo & extensionAbilityInfo)627 bool BundleMgrHelper::QueryExtensionAbilityInfoByUri(
628 const std::string &uri, int32_t userId, ExtensionAbilityInfo &extensionAbilityInfo)
629 {
630 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
631 auto bundleMgr = Connect();
632 if (bundleMgr == nullptr) {
633 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
634 return false;
635 }
636
637 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
638 return bundleMgr->QueryExtensionAbilityInfoByUri(uri, userId, extensionAbilityInfo);
639 }
640
ImplicitQueryInfoByPriority(const Want & want,int32_t flags,int32_t userId,AbilityInfo & abilityInfo,ExtensionAbilityInfo & extensionInfo)641 bool BundleMgrHelper::ImplicitQueryInfoByPriority(
642 const Want &want, int32_t flags, int32_t userId, AbilityInfo &abilityInfo, ExtensionAbilityInfo &extensionInfo)
643 {
644 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
645 auto bundleMgr = Connect();
646 if (bundleMgr == nullptr) {
647 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
648 return false;
649 }
650 AAFwk::Want newWant = want;
651 newWant.RemoveAllFd();
652 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
653 return bundleMgr->ImplicitQueryInfoByPriority(newWant, flags, userId, abilityInfo, extensionInfo);
654 }
655
QueryAbilityInfoByUri(const std::string & abilityUri,int32_t userId,AbilityInfo & abilityInfo)656 bool BundleMgrHelper::QueryAbilityInfoByUri(const std::string &abilityUri, int32_t userId, AbilityInfo &abilityInfo)
657 {
658 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
659 auto bundleMgr = Connect();
660 if (bundleMgr == nullptr) {
661 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
662 return false;
663 }
664
665 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
666 return bundleMgr->QueryAbilityInfoByUri(abilityUri, userId, abilityInfo);
667 }
668
QueryAbilityInfo(const Want & want,int32_t flags,int32_t userId,AbilityInfo & abilityInfo,const sptr<IRemoteObject> & callBack)669 bool BundleMgrHelper::QueryAbilityInfo(
670 const Want &want, int32_t flags, int32_t userId, AbilityInfo &abilityInfo, const sptr<IRemoteObject> &callBack)
671 {
672 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
673 auto bundleMgr = Connect();
674 if (bundleMgr == nullptr) {
675 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
676 return false;
677 }
678
679 AAFwk::Want newWant = want;
680 newWant.RemoveAllFd();
681 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
682 return bundleMgr->QueryAbilityInfo(newWant, flags, userId, abilityInfo, callBack);
683 }
684
UpgradeAtomicService(const Want & want,int32_t userId)685 void BundleMgrHelper::UpgradeAtomicService(const Want &want, int32_t userId)
686 {
687 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
688 auto bundleMgr = Connect();
689 if (bundleMgr == nullptr) {
690 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
691 return;
692 }
693
694 AAFwk::Want newWant = want;
695 newWant.RemoveAllFd();
696 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
697 bundleMgr->UpgradeAtomicService(newWant, userId);
698 }
699
ImplicitQueryInfos(const Want & want,int32_t flags,int32_t userId,bool withDefault,std::vector<AbilityInfo> & abilityInfos,std::vector<ExtensionAbilityInfo> & extensionInfos)700 bool BundleMgrHelper::ImplicitQueryInfos(const Want &want, int32_t flags, int32_t userId, bool withDefault,
701 std::vector<AbilityInfo> &abilityInfos, std::vector<ExtensionAbilityInfo> &extensionInfos)
702 {
703 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
704 auto bundleMgr = Connect();
705 if (bundleMgr == nullptr) {
706 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
707 return false;
708 }
709
710 AAFwk::Want newWant = want;
711 newWant.RemoveAllFd();
712 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
713 bool findDefaultApp = false;
714 bool ret = bundleMgr->ImplicitQueryInfos(newWant, flags, userId, withDefault, abilityInfos,
715 extensionInfos, findDefaultApp);
716 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "findDefaultApp is %{public}d.", findDefaultApp);
717 return ret;
718 }
719
CleanBundleDataFiles(const std::string & bundleName,int32_t userId,int32_t appCloneIndex)720 bool BundleMgrHelper::CleanBundleDataFiles(const std::string &bundleName, int32_t userId, int32_t appCloneIndex)
721 {
722 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
723 auto bundleMgr = Connect();
724 if (bundleMgr == nullptr) {
725 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
726 return false;
727 }
728
729 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
730 return bundleMgr->CleanBundleDataFiles(bundleName, userId, appCloneIndex);
731 }
732
QueryDataGroupInfos(const std::string & bundleName,int32_t userId,std::vector<DataGroupInfo> & infos)733 bool BundleMgrHelper::QueryDataGroupInfos(
734 const std::string &bundleName, int32_t userId, std::vector<DataGroupInfo> &infos)
735 {
736 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
737 auto bundleMgr = Connect();
738 if (bundleMgr == nullptr) {
739 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
740 return false;
741 }
742
743 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
744 return bundleMgr->QueryDataGroupInfos(bundleName, userId, infos);
745 }
746
RegisterBundleEventCallback(const sptr<IBundleEventCallback> & bundleEventCallback)747 bool BundleMgrHelper::RegisterBundleEventCallback(const sptr<IBundleEventCallback> &bundleEventCallback)
748 {
749 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
750 if (bundleEventCallback == nullptr) {
751 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "The bundleEventCallback is nullptr");
752 return false;
753 }
754
755 auto bundleMgr = Connect();
756 if (bundleMgr == nullptr) {
757 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
758 return false;
759 }
760
761 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
762 return bundleMgr->RegisterBundleEventCallback(bundleEventCallback);
763 }
764
GetHapModuleInfo(const AbilityInfo & abilityInfo,int32_t userId,HapModuleInfo & hapModuleInfo)765 bool BundleMgrHelper::GetHapModuleInfo(const AbilityInfo &abilityInfo, int32_t userId, HapModuleInfo &hapModuleInfo)
766 {
767 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
768 auto bundleMgr = Connect();
769 if (bundleMgr == nullptr) {
770 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
771 return false;
772 }
773
774 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
775 return bundleMgr->GetHapModuleInfo(abilityInfo, userId, hapModuleInfo);
776 }
777
QueryAppGalleryBundleName(std::string & bundleName)778 bool BundleMgrHelper::QueryAppGalleryBundleName(std::string &bundleName)
779 {
780 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
781 auto bundleMgr = Connect();
782 if (bundleMgr == nullptr) {
783 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
784 return false;
785 }
786
787 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
788 return bundleMgr->QueryAppGalleryBundleName(bundleName);
789 }
790
GetUidByBundleName(const std::string & bundleName,int32_t userId,int32_t appCloneIndex)791 ErrCode BundleMgrHelper::GetUidByBundleName(const std::string &bundleName, int32_t userId, int32_t appCloneIndex)
792 {
793 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
794 auto bundleMgr = Connect();
795 if (bundleMgr == nullptr) {
796 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
797 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
798 }
799
800 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
801 return bundleMgr->GetUidByBundleName(bundleName, userId, appCloneIndex);
802 }
803
QueryExtensionAbilityInfosOnlyWithTypeName(const std::string & extensionTypeName,const uint32_t flag,const int32_t userId,std::vector<ExtensionAbilityInfo> & extensionInfos)804 ErrCode BundleMgrHelper::QueryExtensionAbilityInfosOnlyWithTypeName(const std::string &extensionTypeName,
805 const uint32_t flag, const int32_t userId, std::vector<ExtensionAbilityInfo> &extensionInfos)
806 {
807 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
808 auto bundleMgr = Connect();
809 if (bundleMgr == nullptr) {
810 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
811 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
812 }
813
814 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
815 return bundleMgr->QueryExtensionAbilityInfosOnlyWithTypeName(extensionTypeName, flag, userId, extensionInfos);
816 }
817
GetDefaultAppProxy()818 sptr<IDefaultApp> BundleMgrHelper::GetDefaultAppProxy()
819 {
820 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
821 auto bundleMgr = Connect();
822 if (bundleMgr == nullptr) {
823 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
824 return nullptr;
825 }
826
827 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
828 return bundleMgr->GetDefaultAppProxy();
829 }
830
GetJsonProfile(ProfileType profileType,const std::string & bundleName,const std::string & moduleName,std::string & profile,int32_t userId)831 ErrCode BundleMgrHelper::GetJsonProfile(ProfileType profileType, const std::string &bundleName,
832 const std::string &moduleName, std::string &profile, int32_t userId)
833 {
834 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
835 auto bundleMgr = Connect();
836 if (bundleMgr == nullptr) {
837 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
838 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
839 }
840
841 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
842 return bundleMgr->GetJsonProfile(profileType, bundleName, moduleName, profile, userId);
843 }
844
GetLaunchWantForBundle(const std::string & bundleName,Want & want,int32_t userId)845 ErrCode BundleMgrHelper::GetLaunchWantForBundle(const std::string &bundleName, Want &want, int32_t userId)
846 {
847 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
848 auto bundleMgr = Connect();
849 if (bundleMgr == nullptr) {
850 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
851 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
852 }
853
854 want.RemoveAllFd();
855 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
856 return bundleMgr->GetLaunchWantForBundle(bundleName, want, userId);
857 }
858
QueryCloneAbilityInfo(const ElementName & element,int32_t flags,int32_t appCloneIndex,AbilityInfo & abilityInfo,int32_t userId)859 ErrCode BundleMgrHelper::QueryCloneAbilityInfo(const ElementName &element, int32_t flags, int32_t appCloneIndex,
860 AbilityInfo &abilityInfo, int32_t userId)
861 {
862 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
863 auto bundleMgr = Connect();
864 if (bundleMgr == nullptr) {
865 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
866 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
867 }
868
869 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
870 return bundleMgr->QueryCloneAbilityInfo(element, flags, appCloneIndex, abilityInfo, userId);
871 }
872
GetCloneBundleInfo(const std::string & bundleName,int32_t flags,int32_t appCloneIndex,BundleInfo & bundleInfo,int32_t userId)873 ErrCode BundleMgrHelper::GetCloneBundleInfo(const std::string &bundleName, int32_t flags, int32_t appCloneIndex,
874 BundleInfo &bundleInfo, int32_t userId)
875 {
876 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
877 auto bundleMgr = Connect();
878 if (bundleMgr == nullptr) {
879 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
880 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
881 }
882
883 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
884 return bundleMgr->GetCloneBundleInfo(bundleName, flags, appCloneIndex, bundleInfo, userId);
885 }
886
QueryCloneExtensionAbilityInfoWithAppIndex(const ElementName & element,int32_t flags,int32_t appCloneIndex,ExtensionAbilityInfo & extensionInfo,int32_t userId)887 ErrCode BundleMgrHelper::QueryCloneExtensionAbilityInfoWithAppIndex(const ElementName &element, int32_t flags,
888 int32_t appCloneIndex, ExtensionAbilityInfo &extensionInfo, int32_t userId)
889 {
890 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "called");
891 auto bundleMgr = Connect();
892 if (bundleMgr == nullptr) {
893 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
894 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
895 }
896
897 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
898 return bundleMgr->QueryCloneExtensionAbilityInfoWithAppIndex(element, flags, appCloneIndex, extensionInfo, userId);
899 }
900
GetCloneAppIndexes(const std::string & bundleName,std::vector<int32_t> & appIndexes,int32_t userId)901 ErrCode BundleMgrHelper::GetCloneAppIndexes(const std::string &bundleName, std::vector<int32_t> &appIndexes,
902 int32_t userId)
903 {
904 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "Called");
905 auto bundleMgr = Connect();
906 if (bundleMgr == nullptr) {
907 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
908 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
909 }
910
911 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
912 return bundleMgr->GetCloneAppIndexes(bundleName, appIndexes, userId);
913 }
914
GetSignatureInfoByBundleName(const std::string & bundleName,SignatureInfo & signatureInfo)915 ErrCode BundleMgrHelper::GetSignatureInfoByBundleName(const std::string &bundleName, SignatureInfo &signatureInfo)
916 {
917 TAG_LOGD(AAFwkTag::BUNDLEMGRHELPER, "Called");
918 auto bundleMgr = Connect();
919 if (bundleMgr == nullptr) {
920 TAG_LOGE(AAFwkTag::BUNDLEMGRHELPER, "Failed to connect");
921 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
922 }
923
924 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
925 return bundleMgr->GetSignatureInfoByBundleName(bundleName, signatureInfo);
926 }
927 } // namespace AppExecFwk
928 } // namespace OHOS