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 "local_pending_want.h"
22 #include "want_params_wrapper.h"
23 #include "pending_want.h"
24 #include "want_agent_client.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
CreateLocalWantAgent(const std::shared_ptr<OHOS::AbilityRuntime::ApplicationContext> & context,const LocalWantAgentInfo & paramsInfo,std::shared_ptr<WantAgent> & wantAgent)186 ErrCode WantAgentHelper::CreateLocalWantAgent(const std::shared_ptr<OHOS::AbilityRuntime::ApplicationContext> &context,
187 const LocalWantAgentInfo ¶msInfo, std::shared_ptr<WantAgent> &wantAgent)
188 {
189 if (context == nullptr) {
190 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
191 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
192 }
193 std::vector<std::shared_ptr<Want>> wants = paramsInfo.GetWants();
194 if (wants.empty() || wants[0] == nullptr) {
195 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
196 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
197 }
198
199 WantAgentConstant::OperationType operationType = paramsInfo.GetOperationType();
200 std::string bundleName = context->GetBundleName();
201 std::shared_ptr<LocalPendingWant> localPendingWant = std::make_shared<LocalPendingWant>(bundleName, wants[0],
202 static_cast<int32_t>(operationType));
203 wantAgent = std::make_shared<WantAgent>(localPendingWant);
204 return ERR_OK;
205 }
206
GetType(std::shared_ptr<WantAgent> agent)207 WantAgentConstant::OperationType WantAgentHelper::GetType(std::shared_ptr<WantAgent> agent)
208 {
209 if (agent == nullptr) {
210 return WantAgentConstant::OperationType::UNKNOWN_TYPE;
211 }
212
213 if (agent->IsLocal()) {
214 if (agent->GetLocalPendingWant() == nullptr) {
215 return WantAgentConstant::OperationType::UNKNOWN_TYPE;
216 }
217 return static_cast<WantAgentConstant::OperationType>(agent->GetLocalPendingWant()->GetType());
218 }
219
220 if (agent->GetPendingWant() == nullptr) {
221 return WantAgentConstant::OperationType::UNKNOWN_TYPE;
222 }
223 return agent->GetPendingWant()->GetType(agent->GetPendingWant()->GetTarget());
224 }
225
TriggerWantAgent(std::shared_ptr<WantAgent> agent,const std::shared_ptr<CompletedCallback> & callback,const TriggerInfo & paramsInfo,sptr<CompletedDispatcher> & data,sptr<IRemoteObject> callerToken)226 ErrCode WantAgentHelper::TriggerWantAgent(std::shared_ptr<WantAgent> agent,
227 const std::shared_ptr<CompletedCallback> &callback, const TriggerInfo ¶msInfo,
228 sptr<CompletedDispatcher> &data, sptr<IRemoteObject> callerToken)
229 {
230 TAG_LOGD(AAFwkTag::WANTAGENT, "call");
231 if (agent == nullptr) {
232 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
233 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
234 }
235
236 sptr<CompletedDispatcher> dispatcher = nullptr;
237 if (agent->IsLocal()) {
238 std::shared_ptr<LocalPendingWant> localPendingWant = agent->GetLocalPendingWant();
239 if (callback != nullptr) {
240 if (callerToken != nullptr) {
241 dispatcher = new (std::nothrow) CompletedDispatcher(localPendingWant, nullptr, nullptr);
242 } else {
243 dispatcher = new (std::nothrow) CompletedDispatcher(localPendingWant, callback, nullptr);
244 }
245 }
246 int32_t res = Send(localPendingWant, dispatcher, paramsInfo, callerToken);
247 data = std::move(dispatcher);
248 return res;
249 }
250
251 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
252 WantAgentConstant::OperationType type = GetType(agent);
253 if (callback != nullptr) {
254 if (callerToken != nullptr) {
255 dispatcher = new (std::nothrow) CompletedDispatcher(pendingWant, nullptr, nullptr);
256 } else {
257 dispatcher = new (std::nothrow) CompletedDispatcher(pendingWant, callback, nullptr);
258 }
259 }
260 int32_t res = Send(pendingWant, type, dispatcher, paramsInfo, callerToken);
261 data = std::move(dispatcher);
262 return res;
263 }
264
Send(const std::shared_ptr<PendingWant> & pendingWant,WantAgentConstant::OperationType type,sptr<CompletedDispatcher> & callBack,const TriggerInfo & paramsInfo,sptr<IRemoteObject> callerToken)265 ErrCode WantAgentHelper::Send(const std::shared_ptr<PendingWant> &pendingWant,
266 WantAgentConstant::OperationType type, sptr<CompletedDispatcher> &callBack, const TriggerInfo ¶msInfo,
267 sptr<IRemoteObject> callerToken)
268 {
269 TAG_LOGD(AAFwkTag::WANTAGENT, "call");
270 if (pendingWant == nullptr) {
271 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
272 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
273 }
274
275 return pendingWant->Send(paramsInfo.GetResultCode(),
276 paramsInfo.GetWant(),
277 callBack,
278 paramsInfo.GetPermission(),
279 paramsInfo.GetExtraInfo(),
280 paramsInfo.GetStartOptions(),
281 pendingWant->GetTarget(),
282 callerToken);
283 }
284
Send(const std::shared_ptr<LocalPendingWant> & localPendingWant,const sptr<CompletedDispatcher> & callBack,const TriggerInfo & paramsInfo,sptr<IRemoteObject> callerToken)285 ErrCode WantAgentHelper::Send(const std::shared_ptr<LocalPendingWant> &localPendingWant,
286 const sptr<CompletedDispatcher> &callBack, const TriggerInfo ¶msInfo,
287 sptr<IRemoteObject> callerToken)
288 {
289 TAG_LOGD(AAFwkTag::WANTAGENT, "call");
290 if (localPendingWant == nullptr) {
291 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
292 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
293 }
294 return localPendingWant->Send(callBack, paramsInfo, callerToken);
295 }
296
Cancel(const std::shared_ptr<WantAgent> agent,uint32_t flags)297 ErrCode WantAgentHelper::Cancel(const std::shared_ptr<WantAgent> agent, uint32_t flags)
298 {
299 if (agent == nullptr) {
300 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
301 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
302 }
303
304 if (agent->IsLocal()) {
305 return NO_ERROR;
306 }
307
308 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
309 if (pendingWant == nullptr) {
310 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
311 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
312 }
313
314 return pendingWant->Cancel(pendingWant->GetTarget(), flags);
315 }
316
IsEquals(const std::shared_ptr<WantAgent> & agent,const std::shared_ptr<WantAgent> & otherAgent)317 ErrCode WantAgentHelper::IsEquals(
318 const std::shared_ptr<WantAgent> &agent, const std::shared_ptr<WantAgent> &otherAgent)
319 {
320 if ((agent == nullptr) && (otherAgent == nullptr)) {
321 return ERR_OK;
322 }
323
324 if ((agent == nullptr) || (otherAgent == nullptr)) {
325 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
326 }
327
328 const int32_t NOTEQ = -1;
329 if (agent->IsLocal() != otherAgent->IsLocal()) {
330 return NOTEQ;
331 }
332 if (agent->IsLocal() == true && otherAgent->IsLocal() == true) {
333 return LocalPendingWant::IsEquals(agent->GetLocalPendingWant(), otherAgent->GetLocalPendingWant());
334 }
335
336 return PendingWant::IsEquals(agent->GetPendingWant(), otherAgent->GetPendingWant());
337 }
338
GetBundleName(const std::shared_ptr<WantAgent> & agent,std::string & bundleName)339 ErrCode WantAgentHelper::GetBundleName(const std::shared_ptr<WantAgent> &agent, std::string &bundleName)
340 {
341 TAG_LOGD(AAFwkTag::WANTAGENT, "called");
342 if (agent == nullptr) {
343 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
344 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
345 }
346
347 if (agent->IsLocal()) {
348 if (agent->GetLocalPendingWant() == nullptr) {
349 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
350 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
351 }
352 bundleName = agent->GetLocalPendingWant()->GetBundleName();
353 return NO_ERROR;
354 }
355
356 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
357 if (pendingWant == nullptr) {
358 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
359 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
360 }
361
362 return pendingWant->GetBundleName(pendingWant->GetTarget(), bundleName);
363 }
364
GetUid(const std::shared_ptr<WantAgent> & agent,int32_t & uid)365 ErrCode WantAgentHelper::GetUid(const std::shared_ptr<WantAgent> &agent, int32_t &uid)
366 {
367 if (agent == nullptr) {
368 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
369 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
370 }
371
372 if (agent->IsLocal()) {
373 if (agent->GetLocalPendingWant() == nullptr) {
374 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
375 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
376 }
377 uid = agent->GetLocalPendingWant()->GetUid();
378 return NO_ERROR;
379 }
380
381 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
382 if (pendingWant == nullptr) {
383 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
384 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
385 }
386
387 return pendingWant->GetUid(pendingWant->GetTarget(), uid);
388 }
389
GetWant(const std::shared_ptr<WantAgent> & agent)390 std::shared_ptr<Want> WantAgentHelper::GetWant(const std::shared_ptr<WantAgent> &agent)
391 {
392 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
393 if (agent == nullptr) {
394 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
395 return nullptr;
396 }
397
398 if (agent->IsLocal()) {
399 if (agent->GetLocalPendingWant() == nullptr) {
400 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
401 return nullptr;
402 }
403 return agent->GetLocalPendingWant()->GetWant();
404 }
405
406 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
407 if (pendingWant == nullptr) {
408 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
409 return nullptr;
410 }
411
412 return pendingWant->GetWant(pendingWant->GetTarget());
413 }
414
RegisterCancelListener(const std::shared_ptr<CancelListener> & cancelListener,const std::shared_ptr<WantAgent> & agent)415 void WantAgentHelper::RegisterCancelListener(
416 const std::shared_ptr<CancelListener> &cancelListener, const std::shared_ptr<WantAgent> &agent)
417 {
418 if (agent == nullptr) {
419 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
420 return;
421 }
422
423 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
424 if (pendingWant == nullptr) {
425 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
426 return;
427 }
428
429 pendingWant->RegisterCancelListener(cancelListener, pendingWant->GetTarget());
430 }
431
UnregisterCancelListener(const std::shared_ptr<CancelListener> & cancelListener,const std::shared_ptr<WantAgent> & agent)432 void WantAgentHelper::UnregisterCancelListener(
433 const std::shared_ptr<CancelListener> &cancelListener, const std::shared_ptr<WantAgent> &agent)
434 {
435 if (agent == nullptr) {
436 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
437 return;
438 }
439
440 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
441 if (pendingWant == nullptr) {
442 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
443 return;
444 }
445
446 pendingWant->UnregisterCancelListener(cancelListener, pendingWant->GetTarget());
447 }
448
ToString(const std::shared_ptr<WantAgent> & agent)449 std::string WantAgentHelper::ToString(const std::shared_ptr<WantAgent> &agent)
450 {
451 if (agent == nullptr) {
452 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid param");
453 return "";
454 }
455
456 std::shared_ptr<PendingWant> pendingWant = agent->GetPendingWant();
457 if (pendingWant == nullptr) {
458 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid param");
459 return "";
460 }
461
462 std::shared_ptr<WantSenderInfo> info = pendingWant->GetWantSenderInfo(pendingWant->GetTarget());
463 if (info == nullptr) {
464 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid param");
465 return "";
466 }
467 nlohmann::json jsonObject;
468 jsonObject["requestCode"] = (*info.get()).requestCode;
469 jsonObject["operationType"] = (*info.get()).type;
470 jsonObject["flags"] = (*info.get()).flags;
471
472 nlohmann::json wants = nlohmann::json::array();
473 for (auto &wantInfo : (*info.get()).allWants) {
474 wants.emplace_back(wantInfo.want.ToString());
475 }
476 jsonObject["wants"] = wants;
477
478 if ((*info.get()).allWants.size() > 0) {
479 nlohmann::json paramsObj;
480 AAFwk::WantParamWrapper wWrapper((*info.get()).allWants[0].want.GetParams());
481 paramsObj["extraInfoValue"] = wWrapper.ToString();
482 jsonObject["extraInfo"] = paramsObj;
483 }
484
485 return jsonObject.dump();
486 }
487
FromString(const std::string & jsonString,int32_t uid)488 std::shared_ptr<WantAgent> WantAgentHelper::FromString(const std::string &jsonString, int32_t uid)
489 {
490 if (jsonString.empty()) {
491 return nullptr;
492 }
493 nlohmann::json jsonObject = nlohmann::json::parse(jsonString);
494 if (jsonObject.is_discarded()) {
495 TAG_LOGE(AAFwkTag::WANTAGENT, "Failed to parse json string");
496 return nullptr;
497 }
498 int requestCode = -1;
499 if (jsonObject.contains("requestCode") && jsonObject["requestCode"].is_number_integer()) {
500 requestCode = jsonObject.at("requestCode").get<int>();
501 }
502
503 WantAgentConstant::OperationType operationType = WantAgentConstant::OperationType::UNKNOWN_TYPE;
504 if (jsonObject.contains("operationType") && jsonObject["operationType"].is_number_integer()) {
505 operationType = static_cast<WantAgentConstant::OperationType>(jsonObject.at("operationType").get<int>());
506 }
507
508 std::vector<WantAgentConstant::Flags> flagsVec = ParseFlags(jsonObject);
509
510 std::vector<std::shared_ptr<AAFwk::Want>> wants = {};
511 if (jsonObject.contains("wants") && jsonObject["wants"].is_array()) {
512 for (auto &wantObj : jsonObject.at("wants")) {
513 if (wantObj.is_string()) {
514 auto wantString = wantObj.get<std::string>();
515 wants.emplace_back(std::make_shared<AAFwk::Want>(*Want::FromString(wantString)));
516 }
517 }
518 }
519
520 std::shared_ptr<AAFwk::WantParams> extraInfo = nullptr;
521 if (jsonObject.contains("extraInfo") && jsonObject["extraInfo"].is_object()) {
522 auto extraInfoObj = jsonObject.at("extraInfo");
523 if (extraInfoObj.contains("extraInfoValue") && extraInfoObj["extraInfoValue"].is_string()) {
524 auto pwWrapper = AAFwk::WantParamWrapper::Parse(extraInfoObj.at("extraInfoValue").get<std::string>());
525 AAFwk::WantParams params;
526 if (pwWrapper->GetValue(params) == ERR_OK) {
527 extraInfo = std::make_shared<AAFwk::WantParams>(params);
528 }
529 }
530 }
531 WantAgentInfo info(requestCode, operationType, flagsVec, wants, extraInfo);
532
533 return GetWantAgent(info, INVLID_WANT_AGENT_USER_ID, uid);
534 }
535
ParseFlags(nlohmann::json jsonObject)536 std::vector<WantAgentConstant::Flags> WantAgentHelper::ParseFlags(nlohmann::json jsonObject)
537 {
538 int flags = -1;
539 std::vector<WantAgentConstant::Flags> flagsVec = {};
540 if (jsonObject.contains("flags") && jsonObject.at("flags").is_number_integer()) {
541 flags = jsonObject.at("flags").get<int>();
542 }
543
544 if (flags < 0) {
545 return flagsVec;
546 }
547
548 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_ONE_SHOT)) {
549 flagsVec.emplace_back(WantAgentConstant::Flags::ONE_TIME_FLAG);
550 }
551 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_NO_CREATE)) {
552 flagsVec.emplace_back(WantAgentConstant::Flags::NO_BUILD_FLAG);
553 }
554 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_CANCEL_CURRENT)) {
555 flagsVec.emplace_back(WantAgentConstant::Flags::CANCEL_PRESENT_FLAG);
556 }
557 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_UPDATE_CURRENT)) {
558 flagsVec.emplace_back(WantAgentConstant::Flags::UPDATE_PRESENT_FLAG);
559 }
560 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_IMMUTABLE)) {
561 flagsVec.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
562 }
563 if (static_cast<uint32_t>(flags) & static_cast<uint32_t>(FLAG_ALLOW_CANCEL)) {
564 flagsVec.emplace_back(WantAgentConstant::Flags::ALLOW_CANCEL_FLAG);
565 }
566
567 return flagsVec;
568 }
569
GetType(const std::shared_ptr<WantAgent> & agent,int32_t & operType)570 ErrCode WantAgentHelper::GetType(const std::shared_ptr<WantAgent> &agent, int32_t &operType)
571 {
572 if (agent == nullptr) {
573 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
574 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
575 }
576
577 if (agent->IsLocal()) {
578 if (agent->GetLocalPendingWant() == nullptr) {
579 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
580 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
581 }
582 operType = agent->GetLocalPendingWant()->GetType();
583 return NO_ERROR;
584 }
585
586 if (agent->GetPendingWant() == nullptr) {
587 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
588 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
589 }
590 return agent->GetPendingWant()->GetType(agent->GetPendingWant()->GetTarget(), operType);
591 }
592
GetWant(const std::shared_ptr<WantAgent> & agent,std::shared_ptr<AAFwk::Want> & want)593 ErrCode WantAgentHelper::GetWant(const std::shared_ptr<WantAgent> &agent, std::shared_ptr<AAFwk::Want> &want)
594 {
595 if (agent == nullptr) {
596 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param.");
597 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
598 }
599
600 if (agent->IsLocal()) {
601 if (agent->GetLocalPendingWant() == nullptr) {
602 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
603 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
604 }
605 want = agent->GetLocalPendingWant()->GetWant();
606 return NO_ERROR;
607 }
608
609 if (agent->GetPendingWant() == nullptr) {
610 TAG_LOGE(AAFwkTag::WANTAGENT, "invalid input param");
611 return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
612 }
613
614 return agent->GetPendingWant()->GetWant(agent->GetPendingWant()->GetTarget(), want);
615 }
616 } // namespace OHOS::AbilityRuntime::WantAgent
617