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 #include "app_domain_verify_mgr_service_proxy.h"
16 #include "app_domain_verify_mgr_interface_code.h"
17 #include "system_ability_definition.h"
18 #include "app_domain_verify_parcel_util.h"
19 #include "want.h"
20 #include "sa_interface/app_domain_verify_mgr_interface_code.h"
21
22 namespace OHOS {
23 namespace AppDomainVerify {
AppDomainVerifyMgrServiceProxy(const sptr<IRemoteObject> & object)24 AppDomainVerifyMgrServiceProxy::AppDomainVerifyMgrServiceProxy(const sptr<IRemoteObject>& object)
25 : IRemoteProxy<IAppDomainVerifyMgrService>(object)
26 {
27 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "new instance created.");
28 }
~AppDomainVerifyMgrServiceProxy()29 AppDomainVerifyMgrServiceProxy::~AppDomainVerifyMgrServiceProxy()
30 {
31 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "instance dead.");
32 }
VerifyDomain(const std::string & appIdentifier,const std::string & bundleName,const std::string & fingerprint,const std::vector<SkillUri> & skillUris)33 void AppDomainVerifyMgrServiceProxy::VerifyDomain(const std::string& appIdentifier, const std::string& bundleName,
34 const std::string& fingerprint, const std::vector<SkillUri>& skillUris)
35 {
36 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
37 MessageParcel data;
38 MessageParcel reply;
39 MessageOption option;
40 WRITE_PARCEL_AND_RETURN_IF_FAIL(InterfaceToken, data, GetDescriptor());
41 WRITE_PARCEL_AND_RETURN_IF_FAIL(String, data, appIdentifier);
42 WRITE_PARCEL_AND_RETURN_IF_FAIL(String, data, bundleName);
43 WRITE_PARCEL_AND_RETURN_IF_FAIL(String, data, fingerprint);
44
45 uint32_t size = static_cast<uint32_t>(skillUris.size());
46 WRITE_PARCEL_AND_RETURN_IF_FAIL(Uint32, data, size);
47 for (uint32_t i = 0; i < skillUris.size(); ++i) {
48 WRITE_PARCEL_AND_RETURN_IF_FAIL(Parcelable, data, &skillUris[i]);
49 }
50 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::VERIFY_DOMAIN, data, reply, option);
51 if (error != ERR_NONE) {
52 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "VerifyDomain failed, error: %{public}d", error);
53 }
54 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
55 }
56
ClearDomainVerifyStatus(const std::string & appIdentifier,const std::string & bundleName)57 bool AppDomainVerifyMgrServiceProxy::ClearDomainVerifyStatus(
58 const std::string& appIdentifier, const std::string& bundleName)
59 {
60 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
61 MessageParcel data;
62 MessageParcel reply;
63 MessageOption option;
64 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
65 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, appIdentifier);
66 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, bundleName);
67 int32_t error = Remote()->SendRequest(
68 AppDomainVerifyMgrInterfaceCode::CLEAR_DOMAIN_VERIFY_RESULT, data, reply, option);
69 if (error != ERR_NONE) {
70 APP_DOMAIN_VERIFY_HILOGE(
71 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "ClearDomainVerifyStatus failed, error: %d", error);
72 return false;
73 }
74 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
75 return reply.ReadBool();
76 }
77
FilterAbilities(const OHOS::AAFwk::Want & want,const std::vector<OHOS::AppExecFwk::AbilityInfo> & originAbilityInfos,std::vector<OHOS::AppExecFwk::AbilityInfo> & filteredAbilityInfos)78 bool AppDomainVerifyMgrServiceProxy::FilterAbilities(const OHOS::AAFwk::Want& want,
79 const std::vector<OHOS::AppExecFwk::AbilityInfo>& originAbilityInfos,
80 std::vector<OHOS::AppExecFwk::AbilityInfo>& filteredAbilityInfos)
81 {
82 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
83 MessageParcel data;
84 MessageParcel reply;
85 MessageOption option;
86 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
87 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, data, &want);
88 uint32_t originAbilityInfoSize = static_cast<uint32_t>(originAbilityInfos.size());
89 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, data, originAbilityInfoSize);
90
91 for (uint32_t i = 0; i < originAbilityInfos.size(); ++i) {
92 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, data, &originAbilityInfos[i]);
93 }
94 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::FILTER_ABILITIES, data, reply, option);
95 if (error != ERR_NONE) {
96 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "FilterAbilities failed, error: %d", error);
97 return false;
98 }
99 bool status = false;
100 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
101 if (!status) {
102 APP_DOMAIN_VERIFY_HILOGE(
103 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "FilterAbilities status failed, error: %d", error);
104 return false;
105 }
106 int32_t infoSize = reply.ReadInt32();
107 if (IsInvalidParcelArraySize(infoSize)) {
108 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
109 return false;
110 }
111 for (int32_t i = 0; i < infoSize; i++) {
112 std::unique_ptr<OHOS::AppExecFwk::AbilityInfo> info(reply.ReadParcelable<OHOS::AppExecFwk::AbilityInfo>());
113 if (info == nullptr) {
114 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "Read Parcelable AbilityInfo failed");
115 return false;
116 }
117 filteredAbilityInfos.emplace_back(*info);
118 }
119 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
120 return true;
121 }
122
QueryDomainVerifyStatus(const std::string & bundleName,DomainVerifyStatus & domainVerificationState)123 bool AppDomainVerifyMgrServiceProxy::QueryDomainVerifyStatus(
124 const std::string& bundleName, DomainVerifyStatus& domainVerificationState)
125 {
126 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
127 MessageParcel data;
128 MessageParcel reply;
129 MessageOption option;
130 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
131 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, bundleName);
132
133 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::QUERY_VERIFY_STATUS, data, reply, option);
134 if (error != ERR_NONE) {
135 APP_DOMAIN_VERIFY_HILOGE(
136 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryDomainVerifyStatus failed, error: %d", error);
137 return false;
138 }
139 bool status = false;
140 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
141 if (!status) {
142 APP_DOMAIN_VERIFY_HILOGE(
143 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryDomainVerifyStatus status failed, error: %d", error);
144 return false;
145 }
146 domainVerificationState = static_cast<DomainVerifyStatus>(reply.ReadInt32());
147 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
148 return true;
149 }
150
QueryAllDomainVerifyStatus(BundleVerifyStatusInfo & bundleVerifyStatusInfo)151 bool AppDomainVerifyMgrServiceProxy::QueryAllDomainVerifyStatus(BundleVerifyStatusInfo& bundleVerifyStatusInfo)
152 {
153 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
154 MessageParcel data;
155 MessageParcel reply;
156 MessageOption option;
157 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
158 int32_t error = Remote()->SendRequest(
159 AppDomainVerifyMgrInterfaceCode::QUERY_ALL_VERIFY_STATUS, data, reply, option);
160 if (error != ERR_NONE) {
161 APP_DOMAIN_VERIFY_HILOGE(
162 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAllDomainVerifyStatus failed, error: %d", error);
163 return false;
164 }
165 bool status = false;
166 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
167 if (!status) {
168 APP_DOMAIN_VERIFY_HILOGE(
169 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAllDomainVerifyStatus status failed, error: %d", error);
170 return false;
171 }
172 std::unique_ptr<BundleVerifyStatusInfo> info(reply.ReadParcelable<BundleVerifyStatusInfo>());
173 if (info == nullptr) {
174 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "Read Parcelable BundleVerifyStatusInfo failed");
175 return false;
176 }
177 bundleVerifyStatusInfo.bundleVerifyStatusInfoMap_ = info->bundleVerifyStatusInfoMap_;
178
179 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
180 return true;
181 }
182
SaveDomainVerifyStatus(const std::string & bundleName,const VerifyResultInfo & verifyResultInfo)183 bool AppDomainVerifyMgrServiceProxy::SaveDomainVerifyStatus(
184 const std::string& bundleName, const VerifyResultInfo& verifyResultInfo)
185 {
186 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
187 MessageParcel data;
188 MessageParcel reply;
189 MessageOption option;
190 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
191 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, bundleName);
192 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, data, &verifyResultInfo);
193 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::SAVE_VERIFY_STATUS, data, reply, option);
194 if (error != ERR_NONE) {
195 APP_DOMAIN_VERIFY_HILOGE(
196 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "SaveDomainVerifyStatus failed, error: %d", error);
197 return false;
198 }
199 bool status = false;
200 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
201 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
202 return status;
203 }
IsAtomicServiceUrl(const std::string & url)204 bool AppDomainVerifyMgrServiceProxy::IsAtomicServiceUrl(const std::string& url)
205 {
206 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
207 MessageParcel data;
208 MessageParcel reply;
209 MessageOption option;
210 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
211 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, url);
212 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::IS_ATOMIC_SERVICE_URL, data, reply, option);
213 if (error != ERR_NONE) {
214 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "IsAtomicServiceUrl failed, error: %d", error);
215 return false;
216 }
217 bool status = false;
218 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
219 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
220 return status;
221 }
UpdateWhiteListUrls(const std::vector<std::string> & urls)222 void AppDomainVerifyMgrServiceProxy::UpdateWhiteListUrls(const std::vector<std::string>& urls)
223 {
224 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
225 MessageParcel data;
226 MessageParcel reply;
227 MessageOption option;
228 WRITE_PARCEL_AND_RETURN_IF_FAIL(InterfaceToken, data, GetDescriptor());
229 WRITE_PARCEL_AND_RETURN_IF_FAIL(Uint32, data, urls.size());
230 for (const auto& url : urls) {
231 WRITE_PARCEL_AND_RETURN_IF_FAIL(String, data, url);
232 }
233 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::UPDATE_WHITE_LIST_URLS, data, reply, option);
234 if (error != ERR_NONE) {
235 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "IsAtomicServiceUrl failed, error: %d", error);
236 return;
237 }
238 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
239 }
ConvertToExplicitWant(OHOS::AAFwk::Want & implicitWant,sptr<IConvertCallback> & callback)240 void AppDomainVerifyMgrServiceProxy::ConvertToExplicitWant(
241 OHOS::AAFwk::Want& implicitWant, sptr<IConvertCallback>& callback)
242 {
243 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
244 MessageParcel data;
245 MessageParcel reply;
246 MessageOption option;
247 WRITE_PARCEL_AND_RETURN_IF_FAIL(InterfaceToken, data, GetDescriptor());
248 WRITE_PARCEL_AND_RETURN_IF_FAIL(Parcelable, data, &implicitWant);
249 WRITE_PARCEL_AND_RETURN_IF_FAIL(RemoteObject, data, callback->AsObject());
250
251 int32_t error = Remote()->SendRequest(
252 AppDomainVerifyMgrInterfaceCode::CONVERT_TO_EXPLICIT_WANT, data, reply, option);
253 if (error != ERR_NONE) {
254 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "ConvertToExplicitWant failed, error: %d", error);
255 }
256 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
257 }
QueryAssociatedDomains(const std::string & bundleName,std::vector<std::string> & domains)258 int AppDomainVerifyMgrServiceProxy::QueryAssociatedDomains(
259 const std::string& bundleName, std::vector<std::string>& domains)
260 {
261 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
262 MessageParcel data;
263 MessageParcel reply;
264 MessageOption option;
265 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(InterfaceToken, data, GetDescriptor());
266 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(String, data, bundleName);
267
268 int32_t error = Remote()->SendRequest(
269 AppDomainVerifyMgrInterfaceCode::QUERY_ASSOCIATED_DOMAINS, data, reply, option);
270 if (error != ERR_NONE) {
271 APP_DOMAIN_VERIFY_HILOGE(
272 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAssociatedDomains failed, error: %d", error);
273 return error;
274 }
275 int32_t result = reply.ReadInt32();
276 if (result != 0) {
277 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "result failed, result: %d", result);
278 return result;
279 }
280 int32_t size = reply.ReadInt32();
281 if (IsInvalidParcelArraySize(size)) {
282 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
283 return ERR_INVALID_VALUE;
284 }
285 domains.clear();
286 for (int32_t i = 0; i < size; i++) {
287 std::string domain;
288 READ_PARCEL_AND_RETURN_INT_IF_FAIL(String, reply, domain);
289 domains.emplace_back(domain);
290 }
291 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
292 return result;
293 }
QueryAssociatedBundleNames(const std::string & domain,std::vector<std::string> & bundleNames)294 int AppDomainVerifyMgrServiceProxy::QueryAssociatedBundleNames(
295 const std::string& domain, std::vector<std::string>& bundleNames)
296 {
297 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
298 MessageParcel data;
299 MessageParcel reply;
300 MessageOption option;
301 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(InterfaceToken, data, GetDescriptor());
302 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(String, data, domain);
303
304 int32_t error = Remote()->SendRequest(
305 AppDomainVerifyMgrInterfaceCode::QUERY_ASSOCIATED_BUNDLE_NAMES, data, reply, option);
306 if (error != ERR_NONE) {
307 APP_DOMAIN_VERIFY_HILOGE(
308 APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAssociatedBundleNames failed, error: %d", error);
309 }
310 int32_t result = reply.ReadInt32();
311 if (result != 0) {
312 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "result failed, result: %d", result);
313 return result;
314 }
315 int32_t size = reply.ReadInt32();
316 if (IsInvalidParcelArraySize(size)) {
317 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
318 return E_INTERNAL_ERR;
319 }
320 bundleNames.clear();
321 for (int32_t i = 0; i < size; i++) {
322 std::string bundleName;
323 READ_PARCEL_AND_RETURN_INT_IF_FAIL(String, reply, bundleName);
324 bundleNames.emplace_back(bundleName);
325 }
326 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
327 return result;
328 }
GetDeferredLink(std::string & link)329 int AppDomainVerifyMgrServiceProxy::GetDeferredLink(std::string& link)
330 {
331 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
332 MessageParcel data;
333 MessageParcel reply;
334 MessageOption option;
335 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(InterfaceToken, data, GetDescriptor());
336 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::GET_DEFERRED_LINK, data, reply, option);
337 if (error != ERR_NONE) {
338 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "GetDeferredLink failed, error: %d", error);
339 }
340 int32_t result = reply.ReadInt32();
341 if (result != 0) {
342 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "result failed, result: %d", result);
343 return result;
344 }
345 READ_PARCEL_AND_RETURN_INT_IF_FAIL(String, reply, link);
346 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
347 return result;
348 }
349
QueryAppDetailsWant(const std::string & url,AAFwk::Want & want)350 int AppDomainVerifyMgrServiceProxy::QueryAppDetailsWant(const std::string& url, AAFwk::Want& want)
351 {
352 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
353 MessageParcel data;
354 MessageParcel reply;
355 MessageOption option;
356 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(InterfaceToken, data, GetDescriptor());
357 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(String, data, url);
358 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, data, &want);
359 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::QUERY_APP_DETAILS_WANT, data, reply, option);
360 if (error != ERR_NONE) {
361 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAppDetailsWant failed, error: %d", error);
362 }
363 int32_t result = reply.ReadInt32();
364 if (result != 0) {
365 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "result failed, result: %d", result);
366 return result;
367 }
368 std::unique_ptr<OHOS::AAFwk::Want> w(data.ReadParcelable<OHOS::AAFwk::Want>());
369 if (!w) {
370 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed.");
371 return ERR_INVALID_VALUE;
372 }
373 want = *w;
374 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
375 return result;
376 }
IsShortUrl(const std::string & url)377 bool AppDomainVerifyMgrServiceProxy::IsShortUrl(const std::string& url)
378 {
379 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
380 MessageParcel data;
381 MessageParcel reply;
382 MessageOption option;
383 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
384 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, url);
385 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::IS_SHORT_URL, data, reply, option);
386 if (error != ERR_NONE) {
387 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "IsAtomicServiceUrl failed, error: %d", error);
388 return false;
389 }
390 bool status = false;
391 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
392 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
393 return status;
394 }
ConvertFromShortUrl(AAFwk::Want & originWant,sptr<IConvertCallback> & callback)395 void AppDomainVerifyMgrServiceProxy::ConvertFromShortUrl(AAFwk::Want& originWant, sptr<IConvertCallback>& callback)
396 {
397 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
398 MessageParcel data;
399 MessageParcel reply;
400 MessageOption option;
401 WRITE_PARCEL_AND_RETURN_IF_FAIL(InterfaceToken, data, GetDescriptor());
402 WRITE_PARCEL_AND_RETURN_IF_FAIL(Parcelable, data, &originWant);
403 WRITE_PARCEL_AND_RETURN_IF_FAIL(RemoteObject, data, callback->AsObject());
404
405 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::CONVERT_FROM_SHORT_URL, data, reply, option);
406 if (error != ERR_NONE) {
407 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "ConvertToExplicitWant failed, error: %d", error);
408 }
409 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
410 }
QueryAbilityInfos(const std::string & url,bool withDefault,std::vector<OHOS::AppExecFwk::AbilityInfo> & abilityInfos,bool & findDefaultApp)411 bool AppDomainVerifyMgrServiceProxy::QueryAbilityInfos(const std::string& url, bool withDefault,
412 std::vector<OHOS::AppExecFwk::AbilityInfo>& abilityInfos, bool& findDefaultApp)
413 {
414 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
415 MessageParcel data;
416 MessageParcel reply;
417 MessageOption option;
418 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
419 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, url);
420 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, data, withDefault);
421
422 int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::QUERY_ABILITY_INFOS, data, reply, option);
423 if (error != ERR_NONE) {
424 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "ipc failed, error: %d", error);
425 return false;
426 }
427 bool status{ false };
428 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
429 if (!status) {
430 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "status failed");
431 return false;
432 }
433 int32_t size = reply.ReadInt32();
434 if (IsInvalidParcelArraySize(size)) {
435 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
436 return false;
437 }
438 for (int32_t i = 0; i < size; i++) {
439 std::unique_ptr<OHOS::AppExecFwk::AbilityInfo> info(reply.ReadParcelable<OHOS::AppExecFwk::AbilityInfo>());
440 if (!info) {
441 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable abilityInfo failed.");
442 return false;
443 }
444 abilityInfos.emplace_back(*info);
445 }
446 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, findDefaultApp);
447 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
448 return true;
449 }
450 } // namespace AppDomainVerify
451 } // namespace OHOS
452