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 "bms_extension_client.h"
17 #include "bundle_mgr_service.h"
18
19 namespace OHOS {
20 namespace AppExecFwk {
BmsExtensionClient()21 BmsExtensionClient::BmsExtensionClient()
22 {
23 APP_LOGD("create");
24 bmsExtensionImpl_ = std::make_shared<BmsExtensionDataMgr>();
25 }
26
QueryLauncherAbility(const Want & want,int32_t userId,std::vector<AbilityInfo> & abilityInfos) const27 ErrCode BmsExtensionClient::QueryLauncherAbility(const Want &want, int32_t userId,
28 std::vector<AbilityInfo> &abilityInfos) const
29 {
30 APP_LOGD("start to query launcher abilities from bms extension");
31 auto dataMgr = GetDataMgr();
32 if (dataMgr == nullptr) {
33 APP_LOGW("dataMgr is nullptr");
34 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
35 }
36 if (userId != Constants::ALL_USERID) {
37 int32_t requestUserId = dataMgr->GetUserId(userId);
38 if (requestUserId == Constants::INVALID_USERID) {
39 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
40 }
41 }
42
43 std::string bundleName = want.GetElement().GetBundleName();
44 InnerBundleInfo info;
45 if (!bundleName.empty() && dataMgr->QueryInnerBundleInfo(bundleName, info)) {
46 APP_LOGD("bundle %{public}s has been existed and does not need to find in bms extension",
47 bundleName.c_str());
48 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
49 }
50
51 if (bmsExtensionImpl_ == nullptr) {
52 APP_LOGW("bmsExtensionImpl_ is nullptr");
53 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
54 }
55 ErrCode res = bmsExtensionImpl_->QueryAbilityInfos(want, userId, abilityInfos);
56 if (res != ERR_OK) {
57 APP_LOGD("query ability infos failed due to error code %{public}d", res);
58 return res;
59 }
60 for_each(abilityInfos.begin(), abilityInfos.end(), [this](auto &info) {
61 // if labelId and label of abilityInfo is 0 or empty, replacing them by utilizing the corresponding
62 // elements of applicationInfo
63 ModifyLauncherAbilityInfo(info);
64 });
65 return ERR_OK;
66 }
67
QueryAbilityInfos(const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos,bool isNewVersion) const68 ErrCode BmsExtensionClient::QueryAbilityInfos(const Want &want, int32_t flags, int32_t userId,
69 std::vector<AbilityInfo> &abilityInfos, bool isNewVersion) const
70 {
71 APP_LOGD("start to query abilityInfos from bms extension");
72 auto dataMgr = GetDataMgr();
73 if (dataMgr == nullptr) {
74 APP_LOGW("dataMgr is nullptr");
75 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
76 }
77 if (userId != Constants::ALL_USERID) {
78 int32_t requestUserId = dataMgr->GetUserId(userId);
79 if (requestUserId == Constants::INVALID_USERID) {
80 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
81 }
82 }
83
84 std::string bundleName = want.GetElement().GetBundleName();
85 InnerBundleInfo info;
86 if (!bundleName.empty() && dataMgr->QueryInnerBundleInfo(bundleName, info)) {
87 APP_LOGD("bundle %{public}s has been existed and does not need to find in bms extension",
88 bundleName.c_str());
89 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
90 }
91
92 if (bmsExtensionImpl_ == nullptr) {
93 APP_LOGW("bmsExtensionImpl_ is nullptr");
94 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
95 }
96 ErrCode res = bmsExtensionImpl_->QueryAbilityInfosWithFlag(want, flags, userId, abilityInfos, isNewVersion);
97 if (res != ERR_OK) {
98 APP_LOGD("query ability infos failed due to error code %{public}d", res);
99 return res;
100 }
101 if (abilityInfos.empty()) {
102 APP_LOGD("no ability info can be found from bms extension");
103 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
104 }
105 return ERR_OK;
106 }
107
QueryAbilityInfo(const Want & want,int32_t flags,int32_t userId,AbilityInfo & abilityInfo,bool isNewVersion) const108 ErrCode BmsExtensionClient::QueryAbilityInfo(const Want &want, int32_t flags, int32_t userId,
109 AbilityInfo &abilityInfo, bool isNewVersion) const
110 {
111 APP_LOGD("start to query abilityInfo from bms extension");
112 std::vector<AbilityInfo> abilityInfos;
113 ErrCode res = QueryAbilityInfos(want, flags, userId, abilityInfos, isNewVersion);
114 if (res != ERR_OK) {
115 APP_LOGD("query ability info failed due to error code %{public}d", res);
116 return res;
117 }
118 if (abilityInfos.empty()) {
119 APP_LOGD("no ability info can be found from bms extension");
120 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
121 }
122
123 abilityInfo = abilityInfos[0];
124 return ERR_OK;
125 }
126
GetBundleInfos(int32_t flags,std::vector<BundleInfo> & bundleInfos,int32_t userId,bool isNewVersion) const127 ErrCode BmsExtensionClient::GetBundleInfos(
128 int32_t flags, std::vector<BundleInfo> &bundleInfos, int32_t userId, bool isNewVersion) const
129 {
130 APP_LOGD("start to query bundle infos from bms extension");
131 if (userId != Constants::ALL_USERID) {
132 auto dataMgr = GetDataMgr();
133 if (dataMgr == nullptr) {
134 APP_LOGW("dataMgr is nullptr");
135 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
136 }
137 int32_t requestUserId = dataMgr->GetUserId(userId);
138 if (requestUserId == Constants::INVALID_USERID) {
139 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
140 }
141 }
142 if (bmsExtensionImpl_ == nullptr) {
143 APP_LOGW("bmsExtensionImpl_ is nullptr");
144 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
145 }
146 ErrCode res = bmsExtensionImpl_->GetBundleInfos(flags, bundleInfos, userId, isNewVersion);
147 if (res != ERR_OK) {
148 APP_LOGD("query bundle infos failed due to error code %{public}d", res);
149 return res;
150 }
151
152 return ERR_OK;
153 }
154
GetBundleInfo(const std::string & bundleName,int32_t flags,BundleInfo & bundleInfo,int32_t userId,bool isNewVersion) const155 ErrCode BmsExtensionClient::GetBundleInfo(const std::string &bundleName, int32_t flags,
156 BundleInfo &bundleInfo, int32_t userId, bool isNewVersion) const
157 {
158 APP_LOGD("start to query bundle info from bms extension");
159 auto dataMgr = GetDataMgr();
160 if (dataMgr == nullptr) {
161 APP_LOGW("dataMgr is nullptr");
162 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
163 }
164 if (userId != Constants::ALL_USERID) {
165 int32_t requestUserId = dataMgr->GetUserId(userId);
166 if (requestUserId == Constants::INVALID_USERID) {
167 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
168 }
169 }
170 InnerBundleInfo info;
171 if (dataMgr->QueryInnerBundleInfo(bundleName, info)) {
172 APP_LOGD("bundle %{public}s has been existed and does not need to find in bms extension",
173 bundleName.c_str());
174 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
175 }
176
177 if (bmsExtensionImpl_ == nullptr) {
178 APP_LOGW("bmsExtensionImpl_ is nullptr");
179 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
180 }
181 ErrCode res = bmsExtensionImpl_->GetBundleInfo(bundleName, flags, userId, bundleInfo, isNewVersion);
182 if (res != ERR_OK) {
183 APP_LOGD("query bundle info failed due to error code %{public}d", res);
184 return res;
185 }
186
187 return ERR_OK;
188 }
189
ImplicitQueryAbilityInfos(const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos,bool isNewVersion) const190 ErrCode BmsExtensionClient::ImplicitQueryAbilityInfos(
191 const Want &want, int32_t flags, int32_t userId, std::vector<AbilityInfo> &abilityInfos, bool isNewVersion) const
192 {
193 APP_LOGD("start to implicitly query ability info from bms extension");
194 if (userId != Constants::ALL_USERID) {
195 auto dataMgr = GetDataMgr();
196 if (dataMgr == nullptr) {
197 APP_LOGW("dataMgr is nullptr");
198 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
199 }
200 int32_t requestUserId = dataMgr->GetUserId(userId);
201 if (requestUserId == Constants::INVALID_USERID) {
202 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
203 }
204 }
205
206 ElementName element = want.GetElement();
207 std::string bundleName = element.GetBundleName();
208 std::string abilityName = element.GetAbilityName();
209 // does not support explicit query
210 if (!bundleName.empty() && !abilityName.empty()) {
211 APP_LOGW("implicitly query failed due to bundleName:%{public}s, abilityName:%{public}s not empty",
212 bundleName.c_str(), abilityName.c_str());
213 return ERR_BUNDLE_MANAGER_PARAM_ERROR;
214 }
215 ErrCode res = QueryAbilityInfos(want, flags, userId, abilityInfos, isNewVersion);
216 if (res != ERR_OK) {
217 APP_LOGE("query ability info failed due to error code %{public}d", res);
218 return res;
219 }
220 if (abilityInfos.empty()) {
221 APP_LOGE("no ability info can be found from bms extension");
222 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
223 }
224
225 return ERR_OK;
226 }
227
GetBundleStats(const std::string & bundleName,int32_t userId,std::vector<int64_t> & bundleStats)228 ErrCode BmsExtensionClient::GetBundleStats(
229 const std::string &bundleName, int32_t userId, std::vector<int64_t> &bundleStats)
230 {
231 if (bmsExtensionImpl_ == nullptr) {
232 APP_LOGW("bmsExtensionImpl_ is null");
233 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
234 }
235 return bmsExtensionImpl_->GetBundleStats(bundleName, userId, bundleStats);
236 }
ClearData(const std::string & bundleName,int32_t userId)237 ErrCode BmsExtensionClient::ClearData(const std::string &bundleName, int32_t userId)
238 {
239 if (bmsExtensionImpl_ == nullptr) {
240 APP_LOGW("bmsExtensionImpl_ is null");
241 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
242 }
243 return bmsExtensionImpl_->ClearData(bundleName, userId);
244 }
ClearCache(const std::string & bundleName,sptr<IRemoteObject> callback,int32_t userId)245 ErrCode BmsExtensionClient::ClearCache(const std::string &bundleName, sptr<IRemoteObject> callback, int32_t userId)
246 {
247 if (bmsExtensionImpl_ == nullptr) {
248 APP_LOGW("bmsExtensionImpl_ is null");
249 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
250 }
251 return bmsExtensionImpl_->ClearCache(bundleName, callback, userId);
252 }
GetUidByBundleName(const std::string & bundleName,int32_t userId,int32_t & uid)253 ErrCode BmsExtensionClient::GetUidByBundleName(const std::string &bundleName, int32_t userId, int32_t &uid)
254 {
255 if (bmsExtensionImpl_ == nullptr) {
256 APP_LOGW("bmsExtensionImpl_ is null");
257 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
258 }
259 return bmsExtensionImpl_->GetUidByBundleName(bundleName, userId, uid);
260 }
GetBundleNameByUid(int32_t uid,std::string & bundleName)261 ErrCode BmsExtensionClient::GetBundleNameByUid(int32_t uid, std::string &bundleName)
262 {
263 if (bmsExtensionImpl_ == nullptr) {
264 APP_LOGW("bmsExtensionImpl_ is null");
265 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
266 }
267 return bmsExtensionImpl_->GetBundleNameByUid(uid, bundleName);
268 }
269
ModifyLauncherAbilityInfo(AbilityInfo & abilityInfo) const270 void BmsExtensionClient::ModifyLauncherAbilityInfo(AbilityInfo &abilityInfo) const
271 {
272 if (abilityInfo.labelId == 0) {
273 abilityInfo.labelId = abilityInfo.applicationInfo.labelId;
274 }
275
276 if (abilityInfo.label.empty()) {
277 abilityInfo.label = abilityInfo.applicationInfo.label;
278 }
279
280 if (abilityInfo.iconId == 0) {
281 abilityInfo.iconId = abilityInfo.applicationInfo.iconId;
282 }
283 }
284
GetDataMgr() const285 const std::shared_ptr<BundleDataMgr> BmsExtensionClient::GetDataMgr() const
286 {
287 return DelayedSingleton<BundleMgrService>::GetInstance()->GetDataMgr();
288 }
289 } // AppExecFwk
290 } // OHOS