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