1 /*
2 * Copyright (c) 2021-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 "want_agent_helper.h"
17
18 #include "ability_runtime_error_util.h"
19 #include "hilog_tag_wrapper.h"
20 #include "hitrace_meter.h"
21 #include "want_params_wrapper.h"
22 #include "pending_want.h"
23 #include "want_agent_client.h"
24 #include "want_agent_log_wrapper.h"
25 #include "want_sender_info.h"
26 #include "want_sender_interface.h"
27
28 using namespace OHOS::AAFwk;
29 using namespace OHOS::AppExecFwk;
30 using namespace OHOS::AbilityRuntime;
31 namespace OHOS::AbilityRuntime::WantAgent {
WantAgentHelper()32 WantAgentHelper::WantAgentHelper()
33 {}
34
FlagsTransformer(const std::vector<WantAgentConstant::Flags> & flags)35 unsigned int WantAgentHelper::FlagsTransformer(const std::vector<WantAgentConstant::Flags> &flags)
36 {
37 unsigned int wantFlags = 0;
38 if (flags.empty()) {
39 wantFlags |= static_cast<unsigned int>(FLAG_UPDATE_CURRENT);
40 return wantFlags;
41 }
42
43 for (auto flag : flags) {
44 switch (flag) {
45 case WantAgentConstant::Flags::ONE_TIME_FLAG:
46 wantFlags |= static_cast<unsigned int>(FLAG_ONE_SHOT);
47 break;
48 case WantAgentConstant::Flags::NO_BUILD_FLAG:
49 wantFlags |= static_cast<unsigned int>(FLAG_NO_CREATE);
50 break;
51 case WantAgentConstant::Flags::CANCEL_PRESENT_FLAG:
52 wantFlags |= static_cast<unsigned int>(FLAG_CANCEL_CURRENT);
53 break;
54 case WantAgentConstant::Flags::UPDATE_PRESENT_FLAG:
55 wantFlags |= static_cast<unsigned int>(FLAG_UPDATE_CURRENT);
56 break;
57 case WantAgentConstant::Flags::CONSTANT_FLAG:
58 wantFlags |= static_cast<unsigned int>(FLAG_IMMUTABLE);
59 break;
60 case WantAgentConstant::Flags::REPLACE_ELEMENT:
61 wantFlags |= static_cast<unsigned int>(FLAG_UPDATE_CURRENT);
62 TAG_LOGE(AAFwkTag::WANTAGENT, "Invalid flag:REPLACE_ELEMENT");
63 break;
64 case WantAgentConstant::Flags::REPLACE_ACTION:
65 wantFlags |= static_cast<unsigned int>(FLAG_UPDATE_CURRENT);
66 TAG_LOGE(AAFwkTag::WANTAGENT, "Invalid flag:REPLACE_ACTION");
67 break;
68 case WantAgentConstant::Flags::REPLACE_URI:
69 wantFlags |= static_cast<unsigned int>(FLAG_UPDATE_CURRENT);
70 TAG_LOGE(AAFwkTag::WANTAGENT, "Invalid flag:REPLACE_URI");
71 break;
72 case WantAgentConstant::Flags::REPLACE_ENTITIES:
73 wantFlags |= static_cast<unsigned int>(FLAG_UPDATE_CURRENT);
74 TAG_LOGE(AAFwkTag::WANTAGENT, "Invalid flag:REPLACE_ENTITIES");
75 break;
76 case WantAgentConstant::Flags::REPLACE_BUNDLE:
77 wantFlags |= static_cast<unsigned int>(FLAG_UPDATE_CURRENT);
78 TAG_LOGE(AAFwkTag::WANTAGENT, "Invalid flag:REPLACE_BUNDLE");
79 break;
80 case WantAgentConstant::Flags::ALLOW_CANCEL_FLAG:
81 wantFlags |= static_cast<unsigned int>(FLAG_ALLOW_CANCEL);
82 break;
83 default:
84 TAG_LOGE(AAFwkTag::WANTAGENT, "flags is error");
85 break;
86 }
87 }
88 return wantFlags;
89 }
90
GetWantAgent(const std::shared_ptr<OHOS::AbilityRuntime::ApplicationContext> & context,const WantAgentInfo & paramsInfo,std::shared_ptr<WantAgent> & wantAgent)91 ErrCode WantAgentHelper::GetWantAgent(
92 const std::shared_ptr<OHOS::AbilityRuntime::ApplicationContext> &context,
93 const WantAgentInfo ¶msInfo, std::shared_ptr<WantAgent> &wantAgent)
94 {
95 if (context == nullptr) {
96 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
97 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
98 }
99
100 std::vector<std::shared_ptr<Want>> wants = paramsInfo.GetWants();
101 if (wants.empty()) {
102 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
103 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
104 }
105
106 unsigned int flags = FlagsTransformer(paramsInfo.GetFlags());
107 if (flags == 0) {
108 TAG_LOGE(AAFwkTag::WANTAGENT, "flags invalid");
109 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
110 }
111
112 std::shared_ptr<WantParams> extraInfo = paramsInfo.GetExtraInfo();
113 std::shared_ptr<PendingWant> pendingWant = nullptr;
114 int requestCode = paramsInfo.GetRequestCode();
115 WantAgentConstant::OperationType operationType = paramsInfo.GetOperationType();
116 ErrCode result;
117 switch (operationType) {
118 case WantAgentConstant::OperationType::START_ABILITY:
119 result = PendingWant::GetAbility(context, requestCode, wants[0], flags, extraInfo, pendingWant);
120 break;
121 case WantAgentConstant::OperationType::START_ABILITIES:
122 result = PendingWant::GetAbilities(context, requestCode, wants, flags, extraInfo, pendingWant);
123 break;
124 case WantAgentConstant::OperationType::START_SERVICE:
125 result = PendingWant::GetService(context, requestCode, wants[0], flags, pendingWant);
126 break;
127 case WantAgentConstant::OperationType::START_FOREGROUND_SERVICE:
128 result = PendingWant::GetForegroundService(context, requestCode, wants[0], flags, pendingWant);
129 break;
130 case WantAgentConstant::OperationType::SEND_COMMON_EVENT:
131 result = PendingWant::GetCommonEvent(context, requestCode, wants[0], flags, pendingWant);
132 break;
133 case WantAgentConstant::OperationType::START_SERVICE_EXTENSION:
134 result = PendingWant::GetServiceExtension(context, requestCode, wants[0], flags, pendingWant);
135 break;
136 default:
137 TAG_LOGE(AAFwkTag::WANTAGENT, "operation type is error");
138 result = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
139 break;
140 }
141
142 if (pendingWant == nullptr) {
143 return result;
144 }
145 wantAgent = std::make_shared<WantAgent>(pendingWant);
146 return ERR_OK;
147 }
148
GetWantAgent(const WantAgentInfo & paramsInfo,int32_t userId,int32_t uid)149 std::shared_ptr<WantAgent> WantAgentHelper::GetWantAgent(const WantAgentInfo ¶msInfo, int32_t userId, int32_t uid)
150 {
151 std::vector<std::shared_ptr<Want>> wants = paramsInfo.GetWants();
152 if (wants.empty()) {
153 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
154 return nullptr;
155 }
156
157 std::shared_ptr<Want> want = wants[0];
158 if (want == nullptr) {
159 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
160 return nullptr;
161 }
162
163 WantsInfo wantsInfo;
164 wantsInfo.want = *want;
165 wantsInfo.resolvedTypes = want->GetType();
166 if (paramsInfo.GetExtraInfo() != nullptr && !paramsInfo.GetExtraInfo()->IsEmpty()) {
167 wantsInfo.want.SetParams(*paramsInfo.GetExtraInfo());
168 }
169
170 WantSenderInfo wantSenderInfo;
171 wantSenderInfo.allWants.push_back(wantsInfo);
172 wantSenderInfo.bundleName = want->GetOperation().GetBundleName();
173 wantSenderInfo.flags = FlagsTransformer(paramsInfo.GetFlags());
174 wantSenderInfo.type = static_cast<int32_t>(paramsInfo.GetOperationType());
175 wantSenderInfo.userId = userId;
176 sptr<IWantSender> target = nullptr;
177 WantAgentClient::GetInstance().GetWantSender(wantSenderInfo, nullptr, target, uid);
178 if (target == nullptr) {
179 return nullptr;
180 }
181 std::shared_ptr<WantAgent> agent = std::make_shared<WantAgent>(std::make_shared<PendingWant>(target));
182
183 return agent;
184 }
185
GetType(std::shared_ptr<WantAgent> agent)186 WantAgentConstant::OperationType WantAgentHelper::GetType(std::shared_ptr<WantAgent> agent)
187 {
188 if ((agent == nullptr) || (agent->GetPendingWant() == nullptr)) {
189 return WantAgentConstant::OperationType::UNKNOWN_TYPE;
190 }
191
192 return agent->GetPendingWant()->GetType(agent->GetPendingWant()->GetTarget());
193 }
194
TriggerWantAgent(std::shared_ptr<WantAgent> agent,const std::shared_ptr<CompletedCallback> & callback,const TriggerInfo & paramsInfo)195 ErrCode WantAgentHelper::TriggerWantAgent(std::shared_ptr<WantAgent> agent,
196 const std::shared_ptr<CompletedCallback> &callback, const TriggerInfo ¶msInfo)
197 {
198 TAG_LOGD(AAFwkTag::WANTAGENT, "call");
199 if (agent == nullptr) {
200 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
201 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
202 }
203 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
204 WantAgentConstant::OperationType type = GetType(agent);
205 sptr<CompletedDispatcher> dispatcher = nullptr;
206 if (callback != nullptr) {
207 dispatcher = new (std::nothrow) CompletedDispatcher(pendingWant, callback, nullptr);
208 }
209 return Send(pendingWant, type, dispatcher, paramsInfo);
210 }
211
Send(const std::shared_ptr<PendingWant> & pendingWant,WantAgentConstant::OperationType type,const sptr<CompletedDispatcher> & callBack,const TriggerInfo & paramsInfo)212 ErrCode WantAgentHelper::Send(const std::shared_ptr<PendingWant> &pendingWant,
213 WantAgentConstant::OperationType type, const sptr<CompletedDispatcher> &callBack, const TriggerInfo ¶msInfo)
214 {
215 TAG_LOGD(AAFwkTag::WANTAGENT, "call");
216 if (pendingWant == nullptr) {
217 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
218 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
219 }
220
221 return pendingWant->Send(paramsInfo.GetResultCode(),
222 paramsInfo.GetWant(),
223 callBack,
224 paramsInfo.GetPermission(),
225 paramsInfo.GetExtraInfo(),
226 paramsInfo.GetStartOptions(),
227 pendingWant->GetTarget());
228 }
229
Cancel(const std::shared_ptr<WantAgent> agent,uint32_t flags)230 ErrCode WantAgentHelper::Cancel(const std::shared_ptr<WantAgent> agent, uint32_t flags)
231 {
232 if (agent == nullptr) {
233 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
234 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
235 }
236
237 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
238 if (pendingWant == nullptr) {
239 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
240 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
241 }
242
243 return pendingWant->Cancel(pendingWant->GetTarget(), flags);
244 }
245
IsEquals(const std::shared_ptr<WantAgent> & agent,const std::shared_ptr<WantAgent> & otherAgent)246 ErrCode WantAgentHelper::IsEquals(
247 const std::shared_ptr<WantAgent> &agent, const std::shared_ptr<WantAgent> &otherAgent)
248 {
249 if ((agent == nullptr) && (otherAgent == nullptr)) {
250 return ERR_OK;
251 }
252
253 if ((agent == nullptr) || (otherAgent == nullptr)) {
254 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
255 }
256 return PendingWant::IsEquals(agent->GetPendingWant(), otherAgent->GetPendingWant());
257 }
258
GetBundleName(const std::shared_ptr<WantAgent> & agent,std::string & bundleName)259 ErrCode WantAgentHelper::GetBundleName(const std::shared_ptr<WantAgent> &agent, std::string &bundleName)
260 {
261 TAG_LOGD(AAFwkTag::WANTAGENT, "called");
262 if (agent == nullptr) {
263 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
264 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
265 }
266
267 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
268 if (pendingWant == nullptr) {
269 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
270 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
271 }
272
273 return pendingWant->GetBundleName(pendingWant->GetTarget(), bundleName);
274 }
275
GetUid(const std::shared_ptr<WantAgent> & agent,int32_t & uid)276 ErrCode WantAgentHelper::GetUid(const std::shared_ptr<WantAgent> &agent, int32_t &uid)
277 {
278 if (agent == nullptr) {
279 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
280 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
281 }
282
283 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
284 if (pendingWant == nullptr) {
285 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
286 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
287 }
288
289 return pendingWant->GetUid(pendingWant->GetTarget(), uid);
290 }
291
GetWant(const std::shared_ptr<WantAgent> & agent)292 std::shared_ptr<Want> WantAgentHelper::GetWant(const std::shared_ptr<WantAgent> &agent)
293 {
294 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
295 if (agent == nullptr) {
296 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
297 return nullptr;
298 }
299
300 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
301 if (pendingWant == nullptr) {
302 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
303 return nullptr;
304 }
305
306 return pendingWant->GetWant(pendingWant->GetTarget());
307 }
308
RegisterCancelListener(const std::shared_ptr<CancelListener> & cancelListener,const std::shared_ptr<WantAgent> & agent)309 void WantAgentHelper::RegisterCancelListener(
310 const std::shared_ptr<CancelListener> &cancelListener, const std::shared_ptr<WantAgent> &agent)
311 {
312 if (agent == nullptr) {
313 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
314 return;
315 }
316
317 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
318 if (pendingWant == nullptr) {
319 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
320 return;
321 }
322
323 pendingWant->RegisterCancelListener(cancelListener, pendingWant->GetTarget());
324 }
325
UnregisterCancelListener(const std::shared_ptr<CancelListener> & cancelListener,const std::shared_ptr<WantAgent> & agent)326 void WantAgentHelper::UnregisterCancelListener(
327 const std::shared_ptr<CancelListener> &cancelListener, const std::shared_ptr<WantAgent> &agent)
328 {
329 if (agent == nullptr) {
330 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
331 return;
332 }
333
334 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
335 if (pendingWant == nullptr) {
336 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
337 return;
338 }
339
340 pendingWant->UnregisterCancelListener(cancelListener, pendingWant->GetTarget());
341 }
342
ToString(const std::shared_ptr<WantAgent> & agent)343 std::string WantAgentHelper::ToString(const std::shared_ptr<WantAgent> &agent)
344 {
345 if (agent == nullptr) {
346 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid param");
347 return "";
348 }
349
350 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
351 if (pendingWant == nullptr) {
352 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid param");
353 return "";
354 }
355
356 std::shared_ptr<WantSenderInfo> info = pendingWant->GetWantSenderInfo(pendingWant->GetTarget());
357 if (info == nullptr) {
358 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid param");
359 return "";
360 }
361 nlohmann::json jsonObject;
362 jsonObject["requestCode"] = (*info.get()).requestCode;
363 jsonObject["operationType"] = (*info.get()).type;
364 jsonObject["flags"] = (*info.get()).flags;
365
366 nlohmann::json wants = nlohmann::json::array();
367 for (auto &wantInfo : (*info.get()).allWants) {
368 wants.emplace_back(wantInfo.want.ToString());
369 }
370 jsonObject["wants"] = wants;
371
372 if ((*info.get()).allWants.size() > 0) {
373 nlohmann::json paramsObj;
374 AAFwk::WantParamWrapper wWrapper((*info.get()).allWants[0].want.GetParams());
375 paramsObj["extraInfoValue"] = wWrapper.ToString();
376 jsonObject["extraInfo"] = paramsObj;
377 }
378
379 return jsonObject.dump();
380 }
381
FromString(const std::string & jsonString,int32_t uid)382 std::shared_ptr<WantAgent> WantAgentHelper::FromString(const std::string &jsonString, int32_t uid)
383 {
384 if (jsonString.empty()) {
385 return nullptr;
386 }
387 nlohmann::json jsonObject = nlohmann::json::parse(jsonString);
388 if (jsonObject.is_discarded()) {
389 TAG_LOGE(AAFwkTag::WANTAGENT, "Failed to parse json string");
390 return nullptr;
391 }
392 int requestCode = -1;
393 if (jsonObject.contains("requestCode") && jsonObject["requestCode"].is_number_integer()) {
394 requestCode = jsonObject.at("requestCode").get<int>();
395 }
396
397 WantAgentConstant::OperationType operationType = WantAgentConstant::OperationType::UNKNOWN_TYPE;
398 if (jsonObject.contains("operationType") && jsonObject["operationType"].is_number_integer()) {
399 operationType = static_cast<WantAgentConstant::OperationType>(jsonObject.at("operationType").get<int>());
400 }
401
402 std::vector<WantAgentConstant::Flags> flagsVec = ParseFlags(jsonObject);
403
404 std::vector<std::shared_ptr<AAFwk::Want>> wants = {};
405 if (jsonObject.contains("wants") && jsonObject["wants"].is_array()) {
406 for (auto &wantObj : jsonObject.at("wants")) {
407 if (wantObj.is_string()) {
408 auto wantString = wantObj.get<std::string>();
409 wants.emplace_back(std::make_shared<AAFwk::Want>(*Want::FromString(wantString)));
410 }
411 }
412 }
413
414 std::shared_ptr<AAFwk::WantParams> extraInfo = nullptr;
415 if (jsonObject.contains("extraInfo") && jsonObject["extraInfo"].is_object()) {
416 auto extraInfoObj = jsonObject.at("extraInfo");
417 if (extraInfoObj.contains("extraInfoValue") && extraInfoObj["extraInfoValue"].is_string()) {
418 auto pwWrapper = AAFwk::WantParamWrapper::Parse(extraInfoObj.at("extraInfoValue").get<std::string>());
419 AAFwk::WantParams params;
420 if (pwWrapper->GetValue(params) == ERR_OK) {
421 extraInfo = std::make_shared<AAFwk::WantParams>(params);
422 }
423 }
424 }
425 WantAgentInfo info(requestCode, operationType, flagsVec, wants, extraInfo);
426
427 return GetWantAgent(info, INVLID_WANT_AGENT_USER_ID, uid);
428 }
429
ParseFlags(nlohmann::json jsonObject)430 std::vector<WantAgentConstant::Flags> WantAgentHelper::ParseFlags(nlohmann::json jsonObject)
431 {
432 int flags = -1;
433 std::vector<WantAgentConstant::Flags> flagsVec = {};
434 if (jsonObject.contains("flags") && jsonObject.at("flags").is_number_integer()) {
435 flags = jsonObject.at("flags").get<int>();
436 }
437
438 if (flags < 0) {
439 return flagsVec;
440 }
441
442 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_ONE_SHOT)) {
443 flagsVec.emplace_back(WantAgentConstant::Flags::ONE_TIME_FLAG);
444 }
445 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_NO_CREATE)) {
446 flagsVec.emplace_back(WantAgentConstant::Flags::NO_BUILD_FLAG);
447 }
448 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_CANCEL_CURRENT)) {
449 flagsVec.emplace_back(WantAgentConstant::Flags::CANCEL_PRESENT_FLAG);
450 }
451 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_UPDATE_CURRENT)) {
452 flagsVec.emplace_back(WantAgentConstant::Flags::UPDATE_PRESENT_FLAG);
453 }
454 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_IMMUTABLE)) {
455 flagsVec.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
456 }
457 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_ALLOW_CANCEL)) {
458 flagsVec.emplace_back(WantAgentConstant::Flags::ALLOW_CANCEL_FLAG);
459 }
460
461 return flagsVec;
462 }
463
GetType(const std::shared_ptr<WantAgent> & agent,int32_t & operType)464 ErrCode WantAgentHelper::GetType(const std::shared_ptr<WantAgent> &agent, int32_t &operType)
465 {
466 if ((agent == nullptr) || (agent->GetPendingWant() == nullptr)) {
467 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
468 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
469 }
470
471 return agent->GetPendingWant()->GetType(agent->GetPendingWant()->GetTarget(), operType);
472 }
473
GetWant(const std::shared_ptr<WantAgent> & agent,std::shared_ptr<AAFwk::Want> & want)474 ErrCode WantAgentHelper::GetWant(const std::shared_ptr<WantAgent> &agent, std::shared_ptr<AAFwk::Want> &want)
475 {
476 if ((agent == nullptr) || (agent->GetPendingWant() == nullptr)) {
477 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
478 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
479 }
480
481 return agent->GetPendingWant()->GetWant(agent->GetPendingWant()->GetTarget(), want);
482 }
483 } // namespace OHOS::AbilityRuntime::WantAgent
484