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 "napi_common_want.h"
17
18 #include "napi_common_util.h"
19 #include "array_wrapper.h"
20 #include "bool_wrapper.h"
21 #include "byte_wrapper.h"
22 #include "double_wrapper.h"
23 #include "float_wrapper.h"
24 #include "hilog_tag_wrapper.h"
25 #include "int_wrapper.h"
26 #include "ipc_skeleton.h"
27 #include "js_runtime_utils.h"
28 #include "long_wrapper.h"
29 #include "napi_remote_object.h"
30 #include "remote_object_wrapper.h"
31 #include "short_wrapper.h"
32 #include "string_wrapper.h"
33 #include "tokenid_kit.h"
34 #include "want_params_wrapper.h"
35 #include "zchar_wrapper.h"
36
37 namespace OHOS {
38 namespace AppExecFwk {
39 using namespace OHOS::AbilityRuntime;
40 const int PROPERTIES_SIZE = 2;
41 /**
42 * @brief Init param of wantOptions.
43 *
44 * @param flagMap Indicates flag of list in Want .
45 */
InnerInitWantOptionsData(std::map<std::string,unsigned int> & flagMap)46 void InnerInitWantOptionsData(std::map<std::string, unsigned int> &flagMap)
47 {
48 flagMap.emplace("authReadUriPermission", Want::FLAG_AUTH_READ_URI_PERMISSION);
49 flagMap.emplace("authWriteUriPermission", Want::FLAG_AUTH_WRITE_URI_PERMISSION);
50 flagMap.emplace("abilityForwardResult", Want::FLAG_ABILITY_FORWARD_RESULT);
51 flagMap.emplace("abilityContinuation", Want::FLAG_ABILITY_CONTINUATION);
52 flagMap.emplace("notOhosComponent", Want::FLAG_NOT_OHOS_COMPONENT);
53 flagMap.emplace("abilityFormEnabled", Want::FLAG_ABILITY_FORM_ENABLED);
54 flagMap.emplace("authPersistableUriPermission", Want::FLAG_AUTH_PERSISTABLE_URI_PERMISSION);
55 flagMap.emplace("authPrefixUriPermission", Want::FLAG_AUTH_PREFIX_URI_PERMISSION);
56 flagMap.emplace("abilitySliceMultiDevice", Want::FLAG_ABILITYSLICE_MULTI_DEVICE);
57 flagMap.emplace("startForegroundAbility", Want::FLAG_START_FOREGROUND_ABILITY);
58 flagMap.emplace("installOnDemand", Want::FLAG_INSTALL_ON_DEMAND);
59 flagMap.emplace("abilitySliceForwardResult", Want::FLAG_ABILITYSLICE_FORWARD_RESULT);
60 flagMap.emplace("installWithBackgroundMode", Want::FLAG_INSTALL_WITH_BACKGROUND_MODE);
61 flagMap.emplace("abilityContinuationReversible", Want::FLAG_ABILITY_CONTINUATION_REVERSIBLE);
62 flagMap.emplace("abilityClearMission", Want::FLAG_ABILITY_CLEAR_MISSION);
63 flagMap.emplace("abilityNewMission", Want::FLAG_ABILITY_NEW_MISSION);
64 flagMap.emplace("abilityMissionTop", Want::FLAG_ABILITY_MISSION_TOP);
65 }
66
WrapElementName(napi_env env,const ElementName & elementName)67 napi_value WrapElementName(napi_env env, const ElementName &elementName)
68 {
69 napi_value jsObject = nullptr;
70 NAPI_CALL(env, napi_create_object(env, &jsObject));
71
72 napi_value jsValue = nullptr;
73 NAPI_CALL(env, napi_create_string_utf8(env, elementName.GetDeviceID().c_str(), NAPI_AUTO_LENGTH, &jsValue));
74 NAPI_CALL(env, napi_set_named_property(env, jsObject, "deviceId", jsValue));
75
76 jsValue = nullptr;
77 NAPI_CALL(env, napi_create_string_utf8(env, elementName.GetBundleName().c_str(), NAPI_AUTO_LENGTH, &jsValue));
78 NAPI_CALL(env, napi_set_named_property(env, jsObject, "bundleName", jsValue));
79
80 jsValue = nullptr;
81 NAPI_CALL(env, napi_create_string_utf8(env, elementName.GetAbilityName().c_str(), NAPI_AUTO_LENGTH, &jsValue));
82 NAPI_CALL(env, napi_set_named_property(env, jsObject, "abilityName", jsValue));
83
84 jsValue = nullptr;
85 NAPI_CALL(env, napi_create_string_utf8(env, elementName.GetModuleName().c_str(), NAPI_AUTO_LENGTH, &jsValue));
86 NAPI_CALL(env, napi_set_named_property(env, jsObject, "moduleName", jsValue));
87
88 return jsObject;
89 }
90
UnwrapElementName(napi_env env,napi_value param,ElementName & elementName)91 bool UnwrapElementName(napi_env env, napi_value param, ElementName &elementName)
92 {
93 std::string natValue("");
94 if (UnwrapStringByPropertyName(env, param, "deviceId", natValue)) {
95 elementName.SetDeviceID(natValue);
96 }
97
98 natValue = "";
99 if (UnwrapStringByPropertyName(env, param, "bundleName", natValue)) {
100 elementName.SetBundleName(natValue);
101 }
102
103 natValue = "";
104 if (UnwrapStringByPropertyName(env, param, "abilityName", natValue)) {
105 elementName.SetAbilityName(natValue);
106 }
107
108 natValue = "";
109 if (UnwrapStringByPropertyName(env, param, "moduleName", natValue)) {
110 elementName.SetModuleName(natValue);
111 }
112 return true;
113 }
114
InnerWrapWantParamsChar(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)115 bool InnerWrapWantParamsChar(
116 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
117 {
118 auto value = wantParams.GetParam(key);
119 AAFwk::IChar *ao = AAFwk::IChar::Query(value);
120 if (ao == nullptr) {
121 return false;
122 }
123
124 std::string natValue(static_cast<Char *>(ao)->ToString());
125 napi_value jsValue = WrapStringToJS(env, natValue);
126 if (jsValue == nullptr) {
127 return false;
128 }
129
130 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
131 return true;
132 }
133
InnerWrapWantParamsString(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)134 bool InnerWrapWantParamsString(
135 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
136 {
137 auto value = wantParams.GetParam(key);
138 AAFwk::IString *ao = AAFwk::IString::Query(value);
139 if (ao == nullptr) {
140 return false;
141 }
142
143 std::string natValue = AAFwk::String::Unbox(ao);
144 napi_value jsValue = WrapStringToJS(env, natValue);
145 if (jsValue == nullptr) {
146 return false;
147 }
148
149 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
150 return true;
151 }
152
InnerWrapWantParamsBool(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)153 bool InnerWrapWantParamsBool(
154 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
155 {
156 auto value = wantParams.GetParam(key);
157 AAFwk::IBoolean *bo = AAFwk::IBoolean::Query(value);
158 if (bo == nullptr) {
159 return false;
160 }
161
162 bool natValue = AAFwk::Boolean::Unbox(bo);
163 napi_value jsValue = WrapBoolToJS(env, natValue);
164 if (jsValue == nullptr) {
165 return false;
166 }
167
168 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
169 return true;
170 }
171
InnerWrapWantParamsByte(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)172 bool InnerWrapWantParamsByte(
173 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
174 {
175 auto value = wantParams.GetParam(key);
176 AAFwk::IByte *bo = AAFwk::IByte::Query(value);
177 if (bo == nullptr) {
178 return false;
179 }
180
181 int intValue = (int)AAFwk::Byte::Unbox(bo);
182 napi_value jsValue = WrapInt32ToJS(env, intValue);
183 if (jsValue == nullptr) {
184 return false;
185 }
186
187 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
188 return true;
189 }
190
InnerWrapWantParamsShort(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)191 bool InnerWrapWantParamsShort(
192 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
193 {
194 auto value = wantParams.GetParam(key);
195 AAFwk::IShort *ao = AAFwk::IShort::Query(value);
196 if (ao == nullptr) {
197 return false;
198 }
199
200 short natValue = AAFwk::Short::Unbox(ao);
201 napi_value jsValue = WrapInt32ToJS(env, natValue);
202 if (jsValue == nullptr) {
203 return false;
204 }
205
206 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
207 return true;
208 }
209
InnerWrapWantParamsInt32(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)210 bool InnerWrapWantParamsInt32(
211 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
212 {
213 auto value = wantParams.GetParam(key);
214 AAFwk::IInteger *ao = AAFwk::IInteger::Query(value);
215 if (ao == nullptr) {
216 return false;
217 }
218
219 int natValue = AAFwk::Integer::Unbox(ao);
220 napi_value jsValue = WrapInt32ToJS(env, natValue);
221 if (jsValue == nullptr) {
222 return false;
223 }
224
225 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
226 return true;
227 }
228
InnerWrapWantParamsInt64(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)229 bool InnerWrapWantParamsInt64(
230 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
231 {
232 auto value = wantParams.GetParam(key);
233 AAFwk::ILong *ao = AAFwk::ILong::Query(value);
234 if (ao == nullptr) {
235 return false;
236 }
237
238 int64_t natValue = AAFwk::Long::Unbox(ao);
239 napi_value jsValue = WrapInt64ToJS(env, natValue);
240 if (jsValue == nullptr) {
241 return false;
242 }
243
244 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
245 return true;
246 }
247
InnerWrapWantParamsFloat(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)248 bool InnerWrapWantParamsFloat(
249 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
250 {
251 auto value = wantParams.GetParam(key);
252 AAFwk::IFloat *ao = AAFwk::IFloat::Query(value);
253 if (ao == nullptr) {
254 return false;
255 }
256
257 float natValue = AAFwk::Float::Unbox(ao);
258 napi_value jsValue = WrapDoubleToJS(env, natValue);
259 if (jsValue == nullptr) {
260 return false;
261 }
262
263 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
264 return true;
265 }
266
InnerWrapWantParamsDouble(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)267 bool InnerWrapWantParamsDouble(
268 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
269 {
270 TAG_LOGD(AAFwkTag::JSNAPI, "called");
271 auto value = wantParams.GetParam(key);
272 AAFwk::IDouble *ao = AAFwk::IDouble::Query(value);
273 if (ao == nullptr) {
274 return false;
275 }
276
277 double natValue = AAFwk::Double::Unbox(ao);
278 napi_value jsValue = WrapDoubleToJS(env, natValue);
279 if (jsValue == nullptr) {
280 return false;
281 }
282
283 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
284 return true;
285 }
286
InnerWrapWantParamsWantParams(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)287 bool InnerWrapWantParamsWantParams(
288 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
289 {
290 TAG_LOGD(AAFwkTag::JSNAPI, "key=%{public}s", key.c_str());
291 auto value = wantParams.GetParam(key);
292 AAFwk::IWantParams *o = AAFwk::IWantParams::Query(value);
293 if (o == nullptr) {
294 return false;
295 }
296
297 AAFwk::WantParams wp = AAFwk::WantParamWrapper::Unbox(o);
298 napi_value jsValue = WrapWantParams(env, wp);
299 if (jsValue == nullptr) {
300 return false;
301 }
302
303 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
304 return true;
305 }
306
InnerWrapWantParamsRemoteObject(napi_env env,napi_value jsObject,const std::string & key,const AAFwk::WantParams & wantParams)307 bool InnerWrapWantParamsRemoteObject(
308 napi_env env, napi_value jsObject, const std::string &key, const AAFwk::WantParams &wantParams)
309 {
310 TAG_LOGD(AAFwkTag::JSNAPI, "key=%{public}s", key.c_str());
311 auto value = wantParams.GetParam(key);
312 AAFwk::IRemoteObjectWrap *remoteObjectIWrap = AAFwk::IRemoteObjectWrap::Query(value);
313 if (remoteObjectIWrap == nullptr) {
314 TAG_LOGE(AAFwkTag::JSNAPI, "null remoteObjectIWrap");
315 return false;
316 }
317 auto remoteObject = AAFwk::RemoteObjectWrap::UnBox(remoteObjectIWrap);
318 auto jsValue = NAPI_ohos_rpc_CreateJsRemoteObject(env, remoteObject);
319 if (jsValue == nullptr) {
320 TAG_LOGE(AAFwkTag::JSNAPI, "null jsValue");
321 return false;
322 }
323
324 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
325 return true;
326 }
327
InnerWrapWantParamsArrayChar(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)328 bool InnerWrapWantParamsArrayChar(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
329 {
330 TAG_LOGD(AAFwkTag::JSNAPI, "called");
331 long size = 0;
332 if (ao->GetLength(size) != ERR_OK) {
333 return false;
334 }
335
336 std::vector<std::string> natArray;
337 for (long i = 0; i < size; i++) {
338 sptr<AAFwk::IInterface> iface = nullptr;
339 if (ao->Get(i, iface) == ERR_OK) {
340 AAFwk::IChar *iValue = AAFwk::IChar::Query(iface);
341 if (iValue != nullptr) {
342 std::string str(static_cast<Char *>(iValue)->ToString());
343 natArray.push_back(str);
344 }
345 }
346 }
347
348 napi_value jsValue = WrapArrayStringToJS(env, natArray);
349 if (jsValue != nullptr) {
350 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
351 return true;
352 }
353 return false;
354 }
355
InnerWrapWantParamsArrayString(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)356 bool InnerWrapWantParamsArrayString(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
357 {
358 long size = 0;
359 if (ao->GetLength(size) != ERR_OK) {
360 return false;
361 }
362
363 std::vector<std::string> natArray;
364 for (long i = 0; i < size; i++) {
365 sptr<AAFwk::IInterface> iface = nullptr;
366 if (ao->Get(i, iface) == ERR_OK) {
367 AAFwk::IString *iValue = AAFwk::IString::Query(iface);
368 if (iValue != nullptr) {
369 natArray.push_back(AAFwk::String::Unbox(iValue));
370 }
371 }
372 }
373
374 napi_value jsValue = WrapArrayStringToJS(env, natArray);
375 if (jsValue != nullptr) {
376 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
377 return true;
378 }
379 return false;
380 }
381
InnerWrapWantParamsArrayBool(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)382 bool InnerWrapWantParamsArrayBool(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
383 {
384 long size = 0;
385 if (ao->GetLength(size) != ERR_OK) {
386 return false;
387 }
388
389 std::vector<bool> natArray;
390 for (long i = 0; i < size; i++) {
391 sptr<AAFwk::IInterface> iface = nullptr;
392 if (ao->Get(i, iface) == ERR_OK) {
393 AAFwk::IBoolean *iValue = AAFwk::IBoolean::Query(iface);
394 if (iValue != nullptr) {
395 natArray.push_back(AAFwk::Boolean::Unbox(iValue));
396 }
397 }
398 }
399
400 napi_value jsValue = WrapArrayBoolToJS(env, natArray);
401 if (jsValue != nullptr) {
402 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
403 return true;
404 }
405 return false;
406 }
407
InnerWrapWantParamsArrayShort(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)408 bool InnerWrapWantParamsArrayShort(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
409 {
410 long size = 0;
411 if (ao->GetLength(size) != ERR_OK) {
412 return false;
413 }
414
415 std::vector<int> natArray;
416 for (long i = 0; i < size; i++) {
417 sptr<AAFwk::IInterface> iface = nullptr;
418 if (ao->Get(i, iface) == ERR_OK) {
419 AAFwk::IShort *iValue = AAFwk::IShort::Query(iface);
420 if (iValue != nullptr) {
421 natArray.push_back(AAFwk::Short::Unbox(iValue));
422 }
423 }
424 }
425
426 napi_value jsValue = WrapArrayInt32ToJS(env, natArray);
427 if (jsValue != nullptr) {
428 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
429 return true;
430 }
431 return false;
432 }
InnerWrapWantParamsArrayByte(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)433 bool InnerWrapWantParamsArrayByte(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
434 {
435 long size = 0;
436 if (ao->GetLength(size) != ERR_OK) {
437 return false;
438 }
439
440 std::vector<int> natArray;
441 for (long i = 0; i < size; i++) {
442 sptr<AAFwk::IInterface> iface = nullptr;
443 if (ao->Get(i, iface) == ERR_OK) {
444 AAFwk::IByte *iValue = AAFwk::IByte::Query(iface);
445 if (iValue != nullptr) {
446 int intValue = (int)AAFwk::Byte::Unbox(iValue);
447 natArray.push_back(intValue);
448 }
449 }
450 }
451
452 napi_value jsValue = WrapArrayInt32ToJS(env, natArray);
453 if (jsValue != nullptr) {
454 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
455 return true;
456 }
457 return false;
458 }
459
InnerWrapWantParamsArrayInt32(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)460 bool InnerWrapWantParamsArrayInt32(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
461 {
462 long size = 0;
463 if (ao->GetLength(size) != ERR_OK) {
464 return false;
465 }
466
467 std::vector<int> natArray;
468 for (long i = 0; i < size; i++) {
469 sptr<AAFwk::IInterface> iface = nullptr;
470 if (ao->Get(i, iface) == ERR_OK) {
471 AAFwk::IInteger *iValue = AAFwk::IInteger::Query(iface);
472 if (iValue != nullptr) {
473 natArray.push_back(AAFwk::Integer::Unbox(iValue));
474 }
475 }
476 }
477
478 napi_value jsValue = WrapArrayInt32ToJS(env, natArray);
479 if (jsValue != nullptr) {
480 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
481 return true;
482 }
483 return false;
484 }
485
InnerWrapWantParamsArrayInt64(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)486 bool InnerWrapWantParamsArrayInt64(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
487 {
488 long size = 0;
489 if (ao->GetLength(size) != ERR_OK) {
490 return false;
491 }
492
493 std::vector<int64_t> natArray;
494 for (long i = 0; i < size; i++) {
495 sptr<AAFwk::IInterface> iface = nullptr;
496 if (ao->Get(i, iface) == ERR_OK) {
497 AAFwk::ILong *iValue = AAFwk::ILong::Query(iface);
498 if (iValue != nullptr) {
499 natArray.push_back(AAFwk::Long::Unbox(iValue));
500 }
501 }
502 }
503
504 napi_value jsValue = WrapArrayInt64ToJS(env, natArray);
505 if (jsValue != nullptr) {
506 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
507 return true;
508 }
509 return false;
510 }
511
InnerWrapWantParamsArrayFloat(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)512 bool InnerWrapWantParamsArrayFloat(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
513 {
514 long size = 0;
515 if (ao->GetLength(size) != ERR_OK) {
516 return false;
517 }
518
519 std::vector<double> natArray;
520 for (long i = 0; i < size; i++) {
521 sptr<AAFwk::IInterface> iface = nullptr;
522 if (ao->Get(i, iface) == ERR_OK) {
523 AAFwk::IFloat *iValue = AAFwk::IFloat::Query(iface);
524 if (iValue != nullptr) {
525 natArray.push_back(AAFwk::Float::Unbox(iValue));
526 }
527 }
528 }
529
530 napi_value jsValue = WrapArrayDoubleToJS(env, natArray);
531 if (jsValue != nullptr) {
532 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
533 return true;
534 }
535 return false;
536 }
537
WrapArrayWantParamsToJS(napi_env env,const std::vector<WantParams> & value)538 napi_value WrapArrayWantParamsToJS(napi_env env, const std::vector<WantParams> &value)
539 {
540 napi_value jsArray = nullptr;
541 napi_value jsValue = nullptr;
542 uint32_t index = 0;
543
544 NAPI_CALL(env, napi_create_array(env, &jsArray));
545 for (uint32_t i = 0; i < value.size(); i++) {
546 jsValue = WrapWantParams(env, value[i]);
547 if (jsValue != nullptr) {
548 if (napi_set_element(env, jsArray, index, jsValue) == napi_ok) {
549 index++;
550 }
551 }
552 }
553 return jsArray;
554 }
555
InnerWrapWantParamsArrayDouble(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)556 bool InnerWrapWantParamsArrayDouble(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
557 {
558 long size = 0;
559 if (ao->GetLength(size) != ERR_OK) {
560 return false;
561 }
562
563 std::vector<double> natArray;
564 for (long i = 0; i < size; i++) {
565 sptr<AAFwk::IInterface> iface = nullptr;
566 if (ao->Get(i, iface) == ERR_OK) {
567 AAFwk::IDouble *iValue = AAFwk::IDouble::Query(iface);
568 if (iValue != nullptr) {
569 natArray.push_back(AAFwk::Double::Unbox(iValue));
570 }
571 }
572 }
573
574 napi_value jsValue = WrapArrayDoubleToJS(env, natArray);
575 if (jsValue != nullptr) {
576 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
577 return true;
578 }
579 return false;
580 }
581
InnerWrapWantParamsArrayWantParams(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)582 bool InnerWrapWantParamsArrayWantParams(napi_env env, napi_value jsObject,
583 const std::string &key, sptr<AAFwk::IArray> &ao)
584 {
585 long size = 0;
586 if (ao->GetLength(size) != ERR_OK) {
587 return false;
588 }
589
590 std::vector<WantParams> natArray;
591 for (long i = 0; i < size; i++) {
592 sptr<AAFwk::IInterface> iface = nullptr;
593 if (ao->Get(i, iface) == ERR_OK) {
594 AAFwk::IWantParams *iValue = AAFwk::IWantParams::Query(iface);
595 if (iValue != nullptr) {
596 natArray.push_back(AAFwk::WantParamWrapper::Unbox(iValue));
597 }
598 }
599 }
600
601 napi_value jsValue = WrapArrayWantParamsToJS(env, natArray);
602 if (jsValue != nullptr) {
603 NAPI_CALL_BASE(env, napi_set_named_property(env, jsObject, key.c_str(), jsValue), false);
604 return true;
605 }
606 return false;
607 }
608
InnerWrapWantParamsArray(napi_env env,napi_value jsObject,const std::string & key,sptr<AAFwk::IArray> & ao)609 bool InnerWrapWantParamsArray(napi_env env, napi_value jsObject, const std::string &key, sptr<AAFwk::IArray> &ao)
610 {
611 TAG_LOGD(AAFwkTag::JSNAPI, "key=%{public}s", key.c_str());
612 if (AAFwk::Array::IsStringArray(ao)) {
613 return InnerWrapWantParamsArrayString(env, jsObject, key, ao);
614 } else if (AAFwk::Array::IsBooleanArray(ao)) {
615 return InnerWrapWantParamsArrayBool(env, jsObject, key, ao);
616 } else if (AAFwk::Array::IsShortArray(ao)) {
617 return InnerWrapWantParamsArrayShort(env, jsObject, key, ao);
618 } else if (AAFwk::Array::IsIntegerArray(ao)) {
619 return InnerWrapWantParamsArrayInt32(env, jsObject, key, ao);
620 } else if (AAFwk::Array::IsLongArray(ao)) {
621 return InnerWrapWantParamsArrayInt64(env, jsObject, key, ao);
622 } else if (AAFwk::Array::IsFloatArray(ao)) {
623 return InnerWrapWantParamsArrayFloat(env, jsObject, key, ao);
624 } else if (AAFwk::Array::IsByteArray(ao)) {
625 return InnerWrapWantParamsArrayByte(env, jsObject, key, ao);
626 } else if (AAFwk::Array::IsCharArray(ao)) {
627 return InnerWrapWantParamsArrayChar(env, jsObject, key, ao);
628 } else if (AAFwk::Array::IsDoubleArray(ao)) {
629 return InnerWrapWantParamsArrayDouble(env, jsObject, key, ao);
630 } else if (AAFwk::Array::IsWantParamsArray(ao)) {
631 return InnerWrapWantParamsArrayWantParams(env, jsObject, key, ao);
632 } else {
633 return false;
634 }
635 }
636
WrapWantParams(napi_env env,const AAFwk::WantParams & wantParams)637 napi_value WrapWantParams(napi_env env, const AAFwk::WantParams &wantParams)
638 {
639 napi_value jsObject = nullptr;
640 NAPI_CALL(env, napi_create_object(env, &jsObject));
641
642 napi_value jsValue = nullptr;
643 const std::map<std::string, sptr<AAFwk::IInterface>> paramList = wantParams.GetParams();
644 for (auto iter = paramList.begin(); iter != paramList.end(); iter++) {
645 jsValue = nullptr;
646 if (AAFwk::IString::Query(iter->second) != nullptr) {
647 InnerWrapWantParamsString(env, jsObject, iter->first, wantParams);
648 } else if (AAFwk::IBoolean::Query(iter->second) != nullptr) {
649 InnerWrapWantParamsBool(env, jsObject, iter->first, wantParams);
650 } else if (AAFwk::IShort::Query(iter->second) != nullptr) {
651 InnerWrapWantParamsShort(env, jsObject, iter->first, wantParams);
652 } else if (AAFwk::IInteger::Query(iter->second) != nullptr) {
653 InnerWrapWantParamsInt32(env, jsObject, iter->first, wantParams);
654 } else if (AAFwk::ILong::Query(iter->second) != nullptr) {
655 InnerWrapWantParamsInt64(env, jsObject, iter->first, wantParams);
656 } else if (AAFwk::IFloat::Query(iter->second) != nullptr) {
657 InnerWrapWantParamsFloat(env, jsObject, iter->first, wantParams);
658 } else if (AAFwk::IDouble::Query(iter->second) != nullptr) {
659 InnerWrapWantParamsDouble(env, jsObject, iter->first, wantParams);
660 } else if (AAFwk::IChar::Query(iter->second) != nullptr) {
661 InnerWrapWantParamsChar(env, jsObject, iter->first, wantParams);
662 } else if (AAFwk::IByte::Query(iter->second) != nullptr) {
663 InnerWrapWantParamsByte(env, jsObject, iter->first, wantParams);
664 } else if (AAFwk::IArray::Query(iter->second) != nullptr) {
665 AAFwk::IArray *ao = AAFwk::IArray::Query(iter->second);
666 if (ao != nullptr) {
667 sptr<AAFwk::IArray> array(ao);
668 InnerWrapWantParamsArray(env, jsObject, iter->first, array);
669 }
670 } else if (AAFwk::IWantParams::Query(iter->second) != nullptr) {
671 InnerWrapWantParamsWantParams(env, jsObject, iter->first, wantParams);
672 } else if (AAFwk::IRemoteObjectWrap::Query(iter->second) != nullptr) {
673 InnerWrapWantParamsRemoteObject(env, jsObject, iter->first, wantParams);
674 }
675 }
676 return jsObject;
677 }
678
InnerSetWantParamsArrayObject(napi_env env,const std::string & key,const std::vector<napi_value> & value,AAFwk::WantParams & wantParams)679 bool InnerSetWantParamsArrayObject(napi_env env, const std::string &key,
680 const std::vector<napi_value> &value, AAFwk::WantParams &wantParams)
681 {
682 size_t size = value.size();
683 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(size, AAFwk::g_IID_IWantParams);
684 if (ao != nullptr) {
685 for (size_t i = 0; i < size; i++) {
686 AAFwk::WantParams wp;
687 UnwrapWantParams(env, value[i], wp);
688 ao->Set(i, AAFwk::WantParamWrapper::Box(wp));
689 }
690 wantParams.SetParam(key, ao);
691 return true;
692 } else {
693 return false;
694 }
695 }
696
InnerSetWantParamsArrayString(const std::string & key,const std::vector<std::string> & value,AAFwk::WantParams & wantParams)697 bool InnerSetWantParamsArrayString(
698 const std::string &key, const std::vector<std::string> &value, AAFwk::WantParams &wantParams)
699 {
700 TAG_LOGD(AAFwkTag::JSNAPI, "called");
701 size_t size = value.size();
702 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(size, AAFwk::g_IID_IString);
703 if (ao != nullptr) {
704 for (size_t i = 0; i < size; i++) {
705 ao->Set(i, AAFwk::String::Box(value[i]));
706 }
707 wantParams.SetParam(key, ao);
708 return true;
709 } else {
710 return false;
711 }
712 }
713
InnerSetWantParamsArrayInt(const std::string & key,const std::vector<int> & value,AAFwk::WantParams & wantParams)714 bool InnerSetWantParamsArrayInt(const std::string &key, const std::vector<int> &value, AAFwk::WantParams &wantParams)
715 {
716 size_t size = value.size();
717 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(size, AAFwk::g_IID_IInteger);
718 if (ao != nullptr) {
719 for (size_t i = 0; i < size; i++) {
720 ao->Set(i, AAFwk::Integer::Box(value[i]));
721 }
722 wantParams.SetParam(key, ao);
723 return true;
724 } else {
725 return false;
726 }
727 }
728
InnerSetWantParamsArrayLong(const std::string & key,const std::vector<long> & value,AAFwk::WantParams & wantParams)729 bool InnerSetWantParamsArrayLong(const std::string &key, const std::vector<long> &value, AAFwk::WantParams &wantParams)
730 {
731 size_t size = value.size();
732 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(size, AAFwk::g_IID_ILong);
733 if (ao != nullptr) {
734 for (size_t i = 0; i < size; i++) {
735 ao->Set(i, AAFwk::Long::Box(value[i]));
736 }
737 wantParams.SetParam(key, ao);
738 return true;
739 } else {
740 return false;
741 }
742 }
743
InnerSetWantParamsArrayBool(const std::string & key,const std::vector<bool> & value,AAFwk::WantParams & wantParams)744 bool InnerSetWantParamsArrayBool(const std::string &key, const std::vector<bool> &value, AAFwk::WantParams &wantParams)
745 {
746 size_t size = value.size();
747 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(size, AAFwk::g_IID_IBoolean);
748 if (ao != nullptr) {
749 for (size_t i = 0; i < size; i++) {
750 ao->Set(i, AAFwk::Boolean::Box(value[i]));
751 }
752 wantParams.SetParam(key, ao);
753 return true;
754 } else {
755 return false;
756 }
757 }
758
InnerSetWantParamsArrayDouble(const std::string & key,const std::vector<double> & value,AAFwk::WantParams & wantParams)759 bool InnerSetWantParamsArrayDouble(
760 const std::string &key, const std::vector<double> &value, AAFwk::WantParams &wantParams)
761 {
762 size_t size = value.size();
763 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(size, AAFwk::g_IID_IDouble);
764 if (ao != nullptr) {
765 for (size_t i = 0; i < size; i++) {
766 ao->Set(i, AAFwk::Double::Box(value[i]));
767 }
768 wantParams.SetParam(key, ao);
769 return true;
770 } else {
771 return false;
772 }
773 }
774
InnerUnwrapWantParamsArray(napi_env env,const std::string & key,napi_value param,AAFwk::WantParams & wantParams)775 bool InnerUnwrapWantParamsArray(napi_env env, const std::string &key, napi_value param, AAFwk::WantParams &wantParams)
776 {
777 TAG_LOGD(AAFwkTag::JSNAPI, "called");
778 ComplexArrayData natArrayValue;
779 if (!UnwrapArrayComplexFromJS(env, param, natArrayValue)) {
780 return false;
781 }
782 if (natArrayValue.objectList.size() > 0) {
783 return InnerSetWantParamsArrayObject(env, key, natArrayValue.objectList, wantParams);
784 }
785 if (natArrayValue.stringList.size() > 0) {
786 return InnerSetWantParamsArrayString(key, natArrayValue.stringList, wantParams);
787 }
788 if (natArrayValue.intList.size() > 0) {
789 return InnerSetWantParamsArrayInt(key, natArrayValue.intList, wantParams);
790 }
791 if (natArrayValue.longList.size() > 0) {
792 return InnerSetWantParamsArrayLong(key, natArrayValue.longList, wantParams);
793 }
794 if (natArrayValue.boolList.size() > 0) {
795 return InnerSetWantParamsArrayBool(key, natArrayValue.boolList, wantParams);
796 }
797 if (natArrayValue.doubleList.size() > 0) {
798 return InnerSetWantParamsArrayDouble(key, natArrayValue.doubleList, wantParams);
799 }
800
801 return false;
802 }
803
InnerUnwrapWantParams(napi_env env,const std::string & key,napi_value param,AAFwk::WantParams & wantParams)804 bool InnerUnwrapWantParams(napi_env env, const std::string &key, napi_value param, AAFwk::WantParams &wantParams)
805 {
806 TAG_LOGD(AAFwkTag::JSNAPI, "called");
807 AAFwk::WantParams wp;
808
809 if (UnwrapWantParams(env, param, wp)) {
810 sptr<AAFwk::IWantParams> pWantParams = AAFwk::WantParamWrapper::Box(wp);
811 if (pWantParams != nullptr) {
812 wantParams.SetParam(key, pWantParams);
813 return true;
814 }
815 }
816 return false;
817 }
818
InnerUnwrapWantParamsNumber(napi_env env,const std::string & key,napi_value param,AAFwk::WantParams & wantParams)819 void InnerUnwrapWantParamsNumber(napi_env env, const std::string &key, napi_value param, AAFwk::WantParams &wantParams)
820 {
821 int32_t natValue32 = 0;
822 double natValueDouble = 0.0;
823 bool isReadValue32 = false;
824 bool isReadDouble = false;
825 if (napi_get_value_int32(env, param, &natValue32) == napi_ok) {
826 isReadValue32 = true;
827 }
828
829 if (napi_get_value_double(env, param, &natValueDouble) == napi_ok) {
830 isReadDouble = true;
831 }
832
833 if (isReadValue32 && isReadDouble) {
834 if (abs(natValueDouble - natValue32 * 1.0) > 0.0) {
835 wantParams.SetParam(key, AAFwk::Double::Box(natValueDouble));
836 } else {
837 wantParams.SetParam(key, AAFwk::Integer::Box(natValue32));
838 }
839 } else if (isReadValue32) {
840 wantParams.SetParam(key, AAFwk::Integer::Box(natValue32));
841 } else if (isReadDouble) {
842 wantParams.SetParam(key, AAFwk::Double::Box(natValueDouble));
843 }
844 }
845
BlackListFilter(const std::string & strProName)846 bool BlackListFilter(const std::string &strProName)
847 {
848 if (strProName == Want::PARAM_RESV_WINDOW_MODE) {
849 return true;
850 }
851 if (strProName == Want::PARAM_RESV_DISPLAY_ID) {
852 return true;
853 }
854 return false;
855 }
856
UnwrapWantParams(napi_env env,napi_value param,AAFwk::WantParams & wantParams)857 bool UnwrapWantParams(napi_env env, napi_value param, AAFwk::WantParams &wantParams)
858 {
859 if (!IsTypeForNapiValue(env, param, napi_object)) {
860 return false;
861 }
862
863 napi_valuetype jsValueType = napi_undefined;
864 napi_value jsProNameList = nullptr;
865 uint32_t jsProCount = 0;
866
867 NAPI_CALL_BASE(env, napi_get_property_names(env, param, &jsProNameList), false);
868 NAPI_CALL_BASE(env, napi_get_array_length(env, jsProNameList, &jsProCount), false);
869
870 napi_value jsProName = nullptr;
871 napi_value jsProValue = nullptr;
872 for (uint32_t index = 0; index < jsProCount; index++) {
873 NAPI_CALL_BASE(env, napi_get_element(env, jsProNameList, index, &jsProName), false);
874
875 std::string strProName = UnwrapStringFromJS(env, jsProName);
876 /* skip reserved param */
877 if (BlackListFilter(strProName)) {
878 TAG_LOGD(AAFwkTag::JSNAPI, "%{public}s is filtered.", strProName.c_str());
879 continue;
880 }
881 TAG_LOGD(AAFwkTag::JSNAPI, "property name=%{public}s", strProName.c_str());
882 NAPI_CALL_BASE(env, napi_get_named_property(env, param, strProName.c_str(), &jsProValue), false);
883 NAPI_CALL_BASE(env, napi_typeof(env, jsProValue, &jsValueType), false);
884
885 switch (jsValueType) {
886 case napi_string: {
887 std::string natValue = UnwrapStringFromJS(env, jsProValue);
888 wantParams.SetParam(strProName, AAFwk::String::Box(natValue));
889 break;
890 }
891 case napi_boolean: {
892 bool natValue = false;
893 NAPI_CALL_BASE(env, napi_get_value_bool(env, jsProValue, &natValue), false);
894 wantParams.SetParam(strProName, AAFwk::Boolean::Box(natValue));
895 break;
896 }
897 case napi_number: {
898 InnerUnwrapWantParamsNumber(env, strProName, jsProValue, wantParams);
899 break;
900 }
901 case napi_object: {
902 HandleNapiObject(env, param, jsProValue, strProName, wantParams);
903 break;
904 }
905 default:
906 break;
907 }
908 }
909
910 return true;
911 }
912
HandleNapiObject(napi_env env,napi_value param,napi_value jsProValue,std::string & strProName,AAFwk::WantParams & wantParams)913 void HandleNapiObject(napi_env env, napi_value param, napi_value jsProValue, std::string &strProName,
914 AAFwk::WantParams &wantParams)
915 {
916 if (IsSpecialObject(env, param, strProName, FD, napi_number)) {
917 HandleFdObject(env, param, strProName, wantParams);
918 } else if (IsSpecialObject(env, param, strProName, REMOTE_OBJECT, napi_object)) {
919 auto selfToken = IPCSkeleton::GetSelfTokenID();
920 if (Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) {
921 HandleRemoteObject(env, param, strProName, wantParams);
922 } else {
923 TAG_LOGW(AAFwkTag::JSNAPI, "not system app");
924 }
925 } else {
926 bool isArray = false;
927 if (napi_is_array(env, jsProValue, &isArray) == napi_ok) {
928 if (isArray) {
929 InnerUnwrapWantParamsArray(env, strProName, jsProValue, wantParams);
930 } else {
931 InnerUnwrapWantParams(env, strProName, jsProValue, wantParams);
932 }
933 }
934 }
935 }
936
IsSpecialObject(napi_env env,napi_value param,std::string & strProName,std::string type,napi_valuetype jsValueProType)937 bool IsSpecialObject(napi_env env, napi_value param, std::string &strProName, std::string type,
938 napi_valuetype jsValueProType)
939 {
940 napi_value jsWantParamProValue = nullptr;
941 NAPI_CALL_BASE(env, napi_get_named_property(env, param, strProName.c_str(), &jsWantParamProValue), false);
942
943 napi_valuetype jsValueType = napi_undefined;
944 napi_value jsProValue = nullptr;
945 NAPI_CALL_BASE(env, napi_get_named_property(env, jsWantParamProValue, TYPE_PROPERTY, &jsProValue), false);
946 NAPI_CALL_BASE(env, napi_typeof(env, jsProValue, &jsValueType), false);
947 if (jsValueType != napi_string) {
948 return false;
949 }
950 std::string natValue = UnwrapStringFromJS(env, jsProValue);
951 if (natValue != type) {
952 return false;
953 }
954 napi_value jsProNameList = nullptr;
955 uint32_t jsProCount = 0;
956
957 NAPI_CALL_BASE(env, napi_get_property_names(env, jsWantParamProValue, &jsProNameList), false);
958 NAPI_CALL_BASE(env, napi_get_array_length(env, jsProNameList, &jsProCount), false);
959
960 if (jsProCount != PROPERTIES_SIZE) {
961 TAG_LOGE(AAFwkTag::JSNAPI, "invalid size, not fd object");
962 return false;
963 }
964
965 jsValueType = napi_undefined;
966 jsProValue = nullptr;
967 NAPI_CALL_BASE(env, napi_get_named_property(env, jsWantParamProValue, VALUE_PROPERTY, &jsProValue),
968 false);
969 NAPI_CALL_BASE(env, napi_typeof(env, jsProValue, &jsValueType), false);
970 if (jsValueType != jsValueProType) {
971 TAG_LOGE(AAFwkTag::JSNAPI, "invalid value property, not fd object");
972 return false;
973 }
974
975 return true;
976 }
977
HandleFdObject(napi_env env,napi_value param,std::string & strProName,AAFwk::WantParams & wantParams)978 bool HandleFdObject(napi_env env, napi_value param, std::string &strProName, AAFwk::WantParams &wantParams)
979 {
980 napi_value jsWantParamProValue = nullptr;
981 NAPI_CALL_BASE(env, napi_get_named_property(env, param, strProName.c_str(), &jsWantParamProValue), false);
982 napi_value jsProValue = nullptr;
983 NAPI_CALL_BASE(env, napi_get_named_property(env, jsWantParamProValue, VALUE_PROPERTY, &jsProValue),
984 false);
985
986 int32_t natValue32 = 0;
987 napi_get_value_int32(env, jsProValue, &natValue32);
988 TAG_LOGI(AAFwkTag::JSNAPI, "fd:%{public}d", natValue32);
989 WantParams wp;
990 wp.SetParam(TYPE_PROPERTY, String::Box(FD));
991 wp.SetParam(VALUE_PROPERTY, Integer::Box(natValue32));
992 sptr<AAFwk::IWantParams> pWantParams = AAFwk::WantParamWrapper::Box(wp);
993 wantParams.SetParam(strProName, pWantParams);
994 return true;
995 }
996
HandleRemoteObject(napi_env env,napi_value param,std::string & strProName,AAFwk::WantParams & wantParams)997 bool HandleRemoteObject(napi_env env, napi_value param, std::string &strProName, AAFwk::WantParams &wantParams)
998 {
999 napi_value jsWantParamProValue = nullptr;
1000 NAPI_CALL_BASE(env, napi_get_named_property(env, param, strProName.c_str(), &jsWantParamProValue), false);
1001 napi_value jsProValue = nullptr;
1002 NAPI_CALL_BASE(env, napi_get_named_property(env, jsWantParamProValue, VALUE_PROPERTY, &jsProValue),
1003 false);
1004
1005 sptr<IRemoteObject> remoteObject = NAPI_ohos_rpc_getNativeRemoteObject(env, jsProValue);
1006 if (remoteObject == nullptr) {
1007 TAG_LOGE(AAFwkTag::JSNAPI, "null remoteObject");
1008 return false;
1009 }
1010
1011 WantParams wp;
1012 wp.SetParam(TYPE_PROPERTY, String::Box(REMOTE_OBJECT));
1013 wp.SetParam(VALUE_PROPERTY, AAFwk::RemoteObjectWrap::Box(remoteObject));
1014 sptr<AAFwk::IWantParams> pWantParams = AAFwk::WantParamWrapper::Box(wp);
1015 wantParams.SetParam(strProName, pWantParams);
1016 return true;
1017 }
1018
InnerWrapWantOptions(napi_env env,const Want & want)1019 napi_value InnerWrapWantOptions(napi_env env, const Want &want)
1020 {
1021 napi_value jsObject = nullptr;
1022 std::map<std::string, unsigned int> flagMap;
1023 InnerInitWantOptionsData(flagMap);
1024 unsigned int flags = want.GetFlags();
1025 bool natValue = false;
1026 napi_value jsValue = nullptr;
1027
1028 NAPI_CALL(env, napi_create_object(env, &jsObject));
1029 for (auto iter = flagMap.begin(); iter != flagMap.end(); iter++) {
1030 jsValue = nullptr;
1031 natValue = ((flags & iter->second) == iter->second);
1032 if (napi_get_boolean(env, natValue, &jsValue) == napi_ok) {
1033 SetPropertyValueByPropertyName(env, jsObject, iter->first.c_str(), jsValue);
1034 }
1035 }
1036
1037 return jsObject;
1038 }
1039
InnerUnwrapWantOptions(napi_env env,napi_value param,const char * propertyName,Want & want)1040 bool InnerUnwrapWantOptions(napi_env env, napi_value param, const char *propertyName, Want &want)
1041 {
1042 napi_value jsValue = GetPropertyValueByPropertyName(env, param, propertyName, napi_object);
1043 if (jsValue == nullptr) {
1044 return false;
1045 }
1046
1047 bool natValue = false;
1048 unsigned int flags = 0;
1049 std::map<std::string, unsigned int> flagMap;
1050 InnerInitWantOptionsData(flagMap);
1051 for (auto iter = flagMap.begin(); iter != flagMap.end(); iter++) {
1052 natValue = false;
1053 if (UnwrapBooleanByPropertyName(env, jsValue, iter->first.c_str(), natValue)) {
1054 if (natValue) {
1055 flags |= iter->second;
1056 }
1057 }
1058 }
1059
1060 want.SetFlags(flags);
1061 return true;
1062 }
1063
WrapWant(napi_env env,const Want & want)1064 napi_value WrapWant(napi_env env, const Want &want)
1065 {
1066 napi_value jsObject = nullptr;
1067 napi_value jsValue = nullptr;
1068
1069 NAPI_CALL(env, napi_create_object(env, &jsObject));
1070
1071 napi_value jsElementName = WrapElementName(env, want.GetElement());
1072 if (jsElementName == nullptr) {
1073 TAG_LOGI(AAFwkTag::JSNAPI, "null jsElementName");
1074 return nullptr;
1075 }
1076
1077 jsValue = GetPropertyValueByPropertyName(env, jsElementName, "deviceId", napi_string);
1078 SetPropertyValueByPropertyName(env, jsObject, "deviceId", jsValue);
1079
1080 jsValue = nullptr;
1081 jsValue = GetPropertyValueByPropertyName(env, jsElementName, "bundleName", napi_string);
1082 SetPropertyValueByPropertyName(env, jsObject, "bundleName", jsValue);
1083
1084 jsValue = nullptr;
1085 jsValue = GetPropertyValueByPropertyName(env, jsElementName, "abilityName", napi_string);
1086 SetPropertyValueByPropertyName(env, jsObject, "abilityName", jsValue);
1087
1088 jsValue = nullptr;
1089 jsValue = GetPropertyValueByPropertyName(env, jsElementName, "moduleName", napi_string);
1090 SetPropertyValueByPropertyName(env, jsObject, "moduleName", jsValue);
1091
1092 jsValue = nullptr;
1093 jsValue = WrapStringToJS(env, want.GetUriString());
1094 SetPropertyValueByPropertyName(env, jsObject, "uri", jsValue);
1095
1096 jsValue = nullptr;
1097 jsValue = WrapStringToJS(env, want.GetType());
1098 SetPropertyValueByPropertyName(env, jsObject, "type", jsValue);
1099
1100 jsValue = nullptr;
1101 jsValue = WrapInt32ToJS(env, want.GetFlags());
1102 SetPropertyValueByPropertyName(env, jsObject, "flags", jsValue);
1103
1104 jsValue = nullptr;
1105 jsValue = WrapStringToJS(env, want.GetAction());
1106 SetPropertyValueByPropertyName(env, jsObject, "action", jsValue);
1107
1108 jsValue = nullptr;
1109 jsValue = WrapWantParams(env, want.GetParams());
1110 SetPropertyValueByPropertyName(env, jsObject, "parameters", jsValue);
1111
1112 jsValue = nullptr;
1113 jsValue = WrapWantParamsFD(env, want.GetParams());
1114 SetPropertyValueByPropertyName(env, jsObject, "fds", jsValue);
1115
1116 jsValue = nullptr;
1117 jsValue = WrapArrayStringToJS(env, want.GetEntities());
1118 SetPropertyValueByPropertyName(env, jsObject, "entities", jsValue);
1119
1120 return jsObject;
1121 }
1122
WrapWantParamsFD(napi_env env,const AAFwk::WantParams & wantParams)1123 napi_value WrapWantParamsFD(napi_env env, const AAFwk::WantParams &wantParams)
1124 {
1125 napi_value jsObject = nullptr;
1126 NAPI_CALL(env, napi_create_object(env, &jsObject));
1127 auto paramList = wantParams.GetParams();
1128 WantParams fds;
1129 for (auto it = paramList.begin(); it != paramList.end(); it++) {
1130 if (AAFwk::IWantParams::Query(it->second) == nullptr) {
1131 TAG_LOGW(AAFwkTag::JSNAPI, "not wantpram");
1132 continue;
1133 }
1134 auto value = wantParams.GetParam(it->first);
1135 AAFwk::IWantParams *o = AAFwk::IWantParams::Query(value);
1136 if (o == nullptr) {
1137 return jsObject;
1138 }
1139 AAFwk::WantParams wp = AAFwk::WantParamWrapper::Unbox(o);
1140 auto valueMap = wp.GetParams();
1141 if (valueMap.size() != PROPERTIES_SIZE) {
1142 TAG_LOGD(AAFwkTag::JSNAPI, "not fd");
1143 return jsObject;
1144 }
1145
1146 //type
1147 auto typeIt = valueMap.find(TYPE_PROPERTY);
1148 if (typeIt == valueMap.end()) {
1149 return jsObject;
1150 }
1151 AAFwk::IString *strValue = AAFwk::IString::Query(typeIt->second);
1152 if (strValue == nullptr) {
1153 return jsObject;
1154 }
1155 std::string typeString = AAFwk::String::Unbox(strValue);
1156 if (typeString != FD) {
1157 TAG_LOGD(AAFwkTag::JSNAPI, "not fd");
1158 return jsObject;
1159 }
1160
1161 // value
1162 auto valueIt = valueMap.find(VALUE_PROPERTY);
1163 if (valueIt == valueMap.end()) {
1164 return jsObject;
1165 }
1166 AAFwk::IInteger *intValue = AAFwk::IInteger::Query(valueIt->second);
1167 if (intValue == nullptr) {
1168 return jsObject;
1169 }
1170 fds.SetParam(it->first, intValue);
1171 }
1172 return WrapWantParams(env, fds);
1173 }
1174
UnwrapWant(napi_env env,napi_value param,Want & want)1175 bool UnwrapWant(napi_env env, napi_value param, Want &want)
1176 {
1177 if (!IsTypeForNapiValue(env, param, napi_object)) {
1178 TAG_LOGI(AAFwkTag::JSNAPI, "not napi_object");
1179 return false;
1180 }
1181
1182 napi_value jsValue = GetPropertyValueByPropertyName(env, param, "parameters", napi_object);
1183 if (jsValue != nullptr) {
1184 AAFwk::WantParams wantParams;
1185 if (UnwrapWantParams(env, jsValue, wantParams)) {
1186 want.SetParams(wantParams);
1187 }
1188 }
1189
1190 std::string natValueString("");
1191 if (UnwrapStringByPropertyName(env, param, "action", natValueString)) {
1192 want.SetAction(natValueString);
1193 }
1194
1195 std::vector<std::string> natValueStringList;
1196 if (UnwrapStringArrayByPropertyName(env, param, "entities", natValueStringList)) {
1197 for (size_t i = 0; i < natValueStringList.size(); i++) {
1198 want.AddEntity(natValueStringList[i]);
1199 }
1200 }
1201
1202 natValueString = "";
1203 if (UnwrapStringByPropertyName(env, param, "uri", natValueString)) {
1204 want.SetUri(natValueString);
1205 }
1206
1207 int32_t flags = 0;
1208 if (UnwrapInt32ByPropertyName(env, param, "flags", flags)) {
1209 want.SetFlags(flags);
1210 }
1211
1212 ElementName natElementName;
1213 UnwrapElementName(env, param, natElementName);
1214 want.SetElementName(natElementName.GetDeviceID(), natElementName.GetBundleName(),
1215 natElementName.GetAbilityName(), natElementName.GetModuleName());
1216
1217 natValueString = "";
1218 if (UnwrapStringByPropertyName(env, param, "type", natValueString)) {
1219 want.SetType(natValueString);
1220 }
1221
1222 return true;
1223 }
1224
WrapAbilityResult(napi_env env,const int & resultCode,const AAFwk::Want & want)1225 napi_value WrapAbilityResult(napi_env env, const int &resultCode, const AAFwk::Want &want)
1226 {
1227 napi_value jsObject = nullptr;
1228 napi_value jsValue = nullptr;
1229
1230 NAPI_CALL(env, napi_create_object(env, &jsObject));
1231
1232 jsValue = WrapInt32ToJS(env, resultCode);
1233 SetPropertyValueByPropertyName(env, jsObject, "resultCode", jsValue);
1234
1235 jsValue = nullptr;
1236 jsValue = WrapWant(env, want);
1237 SetPropertyValueByPropertyName(env, jsObject, "want", jsValue);
1238
1239 return jsObject;
1240 }
1241
UnWrapAbilityResult(napi_env env,napi_value param,int & resultCode,AAFwk::Want & want)1242 bool UnWrapAbilityResult(napi_env env, napi_value param, int &resultCode, AAFwk::Want &want)
1243 {
1244 if (!IsTypeForNapiValue(env, param, napi_object)) {
1245 return false;
1246 }
1247
1248 if (!UnwrapInt32ByPropertyName(env, param, "resultCode", resultCode)) {
1249 return false;
1250 }
1251
1252 if (IsExistsByPropertyName(env, param, "want")) {
1253 napi_value jsWant = nullptr;
1254 if (napi_get_named_property(env, param, "want", &jsWant) != napi_ok) {
1255 return false;
1256 }
1257 if (IsTypeForNapiValue(env, jsWant, napi_undefined)) {
1258 return true;
1259 }
1260 if (!UnwrapWant(env, jsWant, want)) {
1261 return false;
1262 }
1263 }
1264 return true;
1265 }
1266
CreateJsWant(napi_env env,const Want & want)1267 napi_value CreateJsWant(napi_env env, const Want &want)
1268 {
1269 napi_value object = nullptr;
1270 napi_create_object(env, &object);
1271
1272 napi_set_named_property(env, object, "deviceId", CreateJsValue(env, want.GetElement().GetDeviceID()));
1273 napi_set_named_property(env, object, "bundleName", CreateJsValue(env, want.GetElement().GetBundleName()));
1274 napi_set_named_property(env, object, "abilityName", CreateJsValue(env, want.GetElement().GetAbilityName()));
1275 napi_set_named_property(env, object, "moduleName", CreateJsValue(env, want.GetElement().GetModuleName()));
1276 napi_set_named_property(env, object, "uri", CreateJsValue(env, want.GetUriString()));
1277 napi_set_named_property(env, object, "type", CreateJsValue(env, want.GetType()));
1278 napi_set_named_property(env, object, "flags", CreateJsValue(env, static_cast<int32_t>(want.GetFlags())));
1279 napi_set_named_property(env, object, "action", CreateJsValue(env, want.GetAction()));
1280 napi_set_named_property(env, object, "parameters", CreateJsWantParams(env, want.GetParams()));
1281 napi_set_named_property(env, object, "entities", CreateNativeArray(env, want.GetEntities()));
1282 return object;
1283 }
1284
CreateJsWantParams(napi_env env,const AAFwk::WantParams & wantParams)1285 napi_value CreateJsWantParams(napi_env env, const AAFwk::WantParams &wantParams)
1286 {
1287 napi_value object = nullptr;
1288 napi_create_object(env, &object);
1289
1290 const std::map<std::string, sptr<AAFwk::IInterface>> paramList = wantParams.GetParams();
1291 for (auto iter = paramList.begin(); iter != paramList.end(); iter++) {
1292 if (AAFwk::IString::Query(iter->second) != nullptr) {
1293 InnerWrapJsWantParams<AAFwk::IString, AAFwk::String, std::string>(
1294 env, object, iter->first, wantParams);
1295 } else if (AAFwk::IBoolean::Query(iter->second) != nullptr) {
1296 InnerWrapJsWantParams<AAFwk::IBoolean, AAFwk::Boolean, bool>(
1297 env, object, iter->first, wantParams);
1298 } else if (AAFwk::IShort::Query(iter->second) != nullptr) {
1299 InnerWrapJsWantParams<AAFwk::IShort, AAFwk::Short, short>(
1300 env, object, iter->first, wantParams);
1301 } else if (AAFwk::IInteger::Query(iter->second) != nullptr) {
1302 InnerWrapJsWantParams<AAFwk::IInteger, AAFwk::Integer, int>(
1303 env, object, iter->first, wantParams);
1304 } else if (AAFwk::ILong::Query(iter->second) != nullptr) {
1305 InnerWrapJsWantParams<AAFwk::ILong, AAFwk::Long, int64_t>(
1306 env, object, iter->first, wantParams);
1307 } else if (AAFwk::IFloat::Query(iter->second) != nullptr) {
1308 InnerWrapJsWantParams<AAFwk::IFloat, AAFwk::Float, float>(
1309 env, object, iter->first, wantParams);
1310 } else if (AAFwk::IDouble::Query(iter->second) != nullptr) {
1311 InnerWrapJsWantParams<AAFwk::IDouble, AAFwk::Double, double>(
1312 env, object, iter->first, wantParams);
1313 } else if (AAFwk::IChar::Query(iter->second) != nullptr) {
1314 InnerWrapJsWantParams<AAFwk::IChar, AAFwk::Char, char>(
1315 env, object, iter->first, wantParams);
1316 } else if (AAFwk::IByte::Query(iter->second) != nullptr) {
1317 InnerWrapJsWantParams<AAFwk::IByte, AAFwk::Byte, int>(
1318 env, object, iter->first, wantParams);
1319 } else if (AAFwk::IArray::Query(iter->second) != nullptr) {
1320 AAFwk::IArray *ao = AAFwk::IArray::Query(iter->second);
1321 if (ao != nullptr) {
1322 sptr<AAFwk::IArray> array(ao);
1323 WrapJsWantParamsArray(env, object, iter->first, array);
1324 }
1325 } else if (AAFwk::IWantParams::Query(iter->second) != nullptr) {
1326 InnerWrapJsWantParamsWantParams(env, object, iter->first, wantParams);
1327 }
1328 }
1329 return object;
1330 }
1331
InnerWrapJsWantParamsWantParams(napi_env env,napi_value object,const std::string & key,const AAFwk::WantParams & wantParams)1332 bool InnerWrapJsWantParamsWantParams(
1333 napi_env env, napi_value object, const std::string &key, const AAFwk::WantParams &wantParams)
1334 {
1335 auto value = wantParams.GetParam(key);
1336 AAFwk::IWantParams *o = AAFwk::IWantParams::Query(value);
1337 if (o != nullptr) {
1338 AAFwk::WantParams wp = AAFwk::WantParamWrapper::Unbox(o);
1339 napi_value propertyValue = CreateJsWantParams(env, wp);
1340 napi_set_named_property(env, object, key.c_str(), propertyValue);
1341 return true;
1342 }
1343 return false;
1344 }
1345
WrapJsWantParamsArray(napi_env env,napi_value object,const std::string & key,sptr<AAFwk::IArray> & ao)1346 bool WrapJsWantParamsArray(napi_env env, napi_value object, const std::string &key, sptr<AAFwk::IArray> &ao)
1347 {
1348 TAG_LOGI(AAFwkTag::JSNAPI, "key=%{public}s", key.c_str());
1349 if (AAFwk::Array::IsStringArray(ao)) {
1350 return InnerWrapWantParamsArray<AAFwk::IString, AAFwk::String, std::string>(
1351 env, object, key, ao);
1352 } else if (AAFwk::Array::IsBooleanArray(ao)) {
1353 return InnerWrapWantParamsArray<AAFwk::IBoolean, AAFwk::Boolean, bool>(
1354 env, object, key, ao);
1355 } else if (AAFwk::Array::IsShortArray(ao)) {
1356 return InnerWrapWantParamsArray<AAFwk::IShort, AAFwk::Short, short>(
1357 env, object, key, ao);
1358 } else if (AAFwk::Array::IsIntegerArray(ao)) {
1359 return InnerWrapWantParamsArray<AAFwk::IInteger, AAFwk::Integer, int>(
1360 env, object, key, ao);
1361 } else if (AAFwk::Array::IsLongArray(ao)) {
1362 return InnerWrapWantParamsArray<AAFwk::ILong, AAFwk::Long, int64_t>(
1363 env, object, key, ao);
1364 } else if (AAFwk::Array::IsFloatArray(ao)) {
1365 return InnerWrapWantParamsArray<AAFwk::IFloat, AAFwk::Float, float>(
1366 env, object, key, ao);
1367 } else if (AAFwk::Array::IsByteArray(ao)) {
1368 return InnerWrapWantParamsArray<AAFwk::IByte, AAFwk::Byte, int>(
1369 env, object, key, ao);
1370 } else if (AAFwk::Array::IsCharArray(ao)) {
1371 return InnerWrapWantParamsArray<AAFwk::IChar, AAFwk::Char, char>(
1372 env, object, key, ao);
1373 } else if (AAFwk::Array::IsDoubleArray(ao)) {
1374 return InnerWrapWantParamsArray<AAFwk::IDouble, AAFwk::Double, double>(
1375 env, object, key, ao);
1376 } else if (AAFwk::Array::IsWantParamsArray(ao)) {
1377 TAG_LOGD(AAFwkTag::JSNAPI, "Array type is WantParams");
1378 return InnerWrapWantParamsArrayWantParams(env, object, key, ao);
1379 } else {
1380 TAG_LOGE(AAFwkTag::JSNAPI, "Array type unknown");
1381 return false;
1382 }
1383 }
1384 } // namespace AppExecFwk
1385 } // namespace OHOS
1386