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 = WrapArrayStringToJS(env, want.GetEntities());
1114     SetPropertyValueByPropertyName(env, jsObject, "entities", jsValue);
1115 
1116     return jsObject;
1117 }
1118 
UnwrapWant(napi_env env,napi_value param,Want & want)1119 bool UnwrapWant(napi_env env, napi_value param, Want &want)
1120 {
1121     if (!IsTypeForNapiValue(env, param, napi_object)) {
1122         TAG_LOGI(AAFwkTag::JSNAPI, "not napi_object");
1123         return false;
1124     }
1125 
1126     napi_value jsValue = GetPropertyValueByPropertyName(env, param, "parameters", napi_object);
1127     if (jsValue != nullptr) {
1128         AAFwk::WantParams wantParams;
1129         if (UnwrapWantParams(env, jsValue, wantParams)) {
1130             want.SetParams(wantParams);
1131         }
1132     }
1133 
1134     std::string natValueString("");
1135     if (UnwrapStringByPropertyName(env, param, "action", natValueString)) {
1136         want.SetAction(natValueString);
1137     }
1138 
1139     std::vector<std::string> natValueStringList;
1140     if (UnwrapStringArrayByPropertyName(env, param, "entities", natValueStringList)) {
1141         for (size_t i = 0; i < natValueStringList.size(); i++) {
1142             want.AddEntity(natValueStringList[i]);
1143         }
1144     }
1145 
1146     natValueString = "";
1147     if (UnwrapStringByPropertyName(env, param, "uri", natValueString)) {
1148         want.SetUri(natValueString);
1149     }
1150 
1151     int32_t flags = 0;
1152     if (UnwrapInt32ByPropertyName(env, param, "flags", flags)) {
1153         want.SetFlags(flags);
1154     }
1155 
1156     ElementName natElementName;
1157     UnwrapElementName(env, param, natElementName);
1158     want.SetElementName(natElementName.GetDeviceID(), natElementName.GetBundleName(),
1159         natElementName.GetAbilityName(), natElementName.GetModuleName());
1160 
1161     natValueString = "";
1162     if (UnwrapStringByPropertyName(env, param, "type", natValueString)) {
1163         want.SetType(natValueString);
1164     }
1165 
1166     return true;
1167 }
1168 
WrapAbilityResult(napi_env env,const int & resultCode,const AAFwk::Want & want)1169 napi_value WrapAbilityResult(napi_env env, const int &resultCode, const AAFwk::Want &want)
1170 {
1171     napi_value jsObject = nullptr;
1172     napi_value jsValue = nullptr;
1173 
1174     NAPI_CALL(env, napi_create_object(env, &jsObject));
1175 
1176     jsValue = WrapInt32ToJS(env, resultCode);
1177     SetPropertyValueByPropertyName(env, jsObject, "resultCode", jsValue);
1178 
1179     jsValue = nullptr;
1180     jsValue = WrapWant(env, want);
1181     SetPropertyValueByPropertyName(env, jsObject, "want", jsValue);
1182 
1183     return jsObject;
1184 }
1185 
UnWrapAbilityResult(napi_env env,napi_value param,int & resultCode,AAFwk::Want & want)1186 bool UnWrapAbilityResult(napi_env env, napi_value param, int &resultCode, AAFwk::Want &want)
1187 {
1188     if (!IsTypeForNapiValue(env, param, napi_object)) {
1189         return false;
1190     }
1191 
1192     if (!UnwrapInt32ByPropertyName(env, param, "resultCode", resultCode)) {
1193         return false;
1194     }
1195 
1196     if (IsExistsByPropertyName(env, param, "want")) {
1197         napi_value jsWant = nullptr;
1198         if (napi_get_named_property(env, param, "want", &jsWant) != napi_ok) {
1199             return false;
1200         }
1201         if (IsTypeForNapiValue(env, jsWant, napi_undefined)) {
1202             return true;
1203         }
1204         if (!UnwrapWant(env, jsWant, want)) {
1205             return false;
1206         }
1207     }
1208     return true;
1209 }
1210 
CreateJsWant(napi_env env,const Want & want)1211 napi_value CreateJsWant(napi_env env, const Want &want)
1212 {
1213     napi_value object = nullptr;
1214     napi_create_object(env, &object);
1215 
1216     napi_set_named_property(env, object, "deviceId", CreateJsValue(env, want.GetElement().GetDeviceID()));
1217     napi_set_named_property(env, object, "bundleName", CreateJsValue(env, want.GetElement().GetBundleName()));
1218     napi_set_named_property(env, object, "abilityName", CreateJsValue(env, want.GetElement().GetAbilityName()));
1219     napi_set_named_property(env, object, "moduleName", CreateJsValue(env, want.GetElement().GetModuleName()));
1220     napi_set_named_property(env, object, "uri", CreateJsValue(env, want.GetUriString()));
1221     napi_set_named_property(env, object, "type", CreateJsValue(env, want.GetType()));
1222     napi_set_named_property(env, object, "flags", CreateJsValue(env, static_cast<int32_t>(want.GetFlags())));
1223     napi_set_named_property(env, object, "action", CreateJsValue(env, want.GetAction()));
1224     napi_set_named_property(env, object, "parameters", CreateJsWantParams(env, want.GetParams()));
1225     napi_set_named_property(env, object, "entities", CreateNativeArray(env, want.GetEntities()));
1226     return object;
1227 }
1228 
CreateJsWantParams(napi_env env,const AAFwk::WantParams & wantParams)1229 napi_value CreateJsWantParams(napi_env env, const AAFwk::WantParams &wantParams)
1230 {
1231     napi_value object = nullptr;
1232     napi_create_object(env, &object);
1233 
1234     const std::map<std::string, sptr<AAFwk::IInterface>> paramList = wantParams.GetParams();
1235     for (auto iter = paramList.begin(); iter != paramList.end(); iter++) {
1236         if (AAFwk::IString::Query(iter->second) != nullptr) {
1237             InnerWrapJsWantParams<AAFwk::IString, AAFwk::String, std::string>(
1238                 env, object, iter->first, wantParams);
1239         } else if (AAFwk::IBoolean::Query(iter->second) != nullptr) {
1240             InnerWrapJsWantParams<AAFwk::IBoolean, AAFwk::Boolean, bool>(
1241                 env, object, iter->first, wantParams);
1242         } else if (AAFwk::IShort::Query(iter->second) != nullptr) {
1243             InnerWrapJsWantParams<AAFwk::IShort, AAFwk::Short, short>(
1244                 env, object, iter->first, wantParams);
1245         } else if (AAFwk::IInteger::Query(iter->second) != nullptr) {
1246             InnerWrapJsWantParams<AAFwk::IInteger, AAFwk::Integer, int>(
1247                 env, object, iter->first, wantParams);
1248         } else if (AAFwk::ILong::Query(iter->second) != nullptr) {
1249             InnerWrapJsWantParams<AAFwk::ILong, AAFwk::Long, int64_t>(
1250                 env, object, iter->first, wantParams);
1251         } else if (AAFwk::IFloat::Query(iter->second) != nullptr) {
1252             InnerWrapJsWantParams<AAFwk::IFloat, AAFwk::Float, float>(
1253                 env, object, iter->first, wantParams);
1254         } else if (AAFwk::IDouble::Query(iter->second) != nullptr) {
1255             InnerWrapJsWantParams<AAFwk::IDouble, AAFwk::Double, double>(
1256                 env, object, iter->first, wantParams);
1257         } else if (AAFwk::IChar::Query(iter->second) != nullptr) {
1258             InnerWrapJsWantParams<AAFwk::IChar, AAFwk::Char, char>(
1259                 env, object, iter->first, wantParams);
1260         } else if (AAFwk::IByte::Query(iter->second) != nullptr) {
1261             InnerWrapJsWantParams<AAFwk::IByte, AAFwk::Byte, int>(
1262                 env, object, iter->first, wantParams);
1263         } else if (AAFwk::IArray::Query(iter->second) != nullptr) {
1264             AAFwk::IArray *ao = AAFwk::IArray::Query(iter->second);
1265             if (ao != nullptr) {
1266                 sptr<AAFwk::IArray> array(ao);
1267                 WrapJsWantParamsArray(env, object, iter->first, array);
1268             }
1269         } else if (AAFwk::IWantParams::Query(iter->second) != nullptr) {
1270             InnerWrapJsWantParamsWantParams(env, object, iter->first, wantParams);
1271         }
1272     }
1273     return object;
1274 }
1275 
InnerWrapJsWantParamsWantParams(napi_env env,napi_value object,const std::string & key,const AAFwk::WantParams & wantParams)1276 bool InnerWrapJsWantParamsWantParams(
1277     napi_env env, napi_value object, const std::string &key, const AAFwk::WantParams &wantParams)
1278 {
1279     auto value = wantParams.GetParam(key);
1280     AAFwk::IWantParams *o = AAFwk::IWantParams::Query(value);
1281     if (o != nullptr) {
1282         AAFwk::WantParams wp = AAFwk::WantParamWrapper::Unbox(o);
1283         napi_value propertyValue = CreateJsWantParams(env, wp);
1284         napi_set_named_property(env, object, key.c_str(), propertyValue);
1285         return true;
1286     }
1287     return false;
1288 }
1289 
WrapJsWantParamsArray(napi_env env,napi_value object,const std::string & key,sptr<AAFwk::IArray> & ao)1290 bool WrapJsWantParamsArray(napi_env env, napi_value object, const std::string &key, sptr<AAFwk::IArray> &ao)
1291 {
1292     TAG_LOGI(AAFwkTag::JSNAPI, "key=%{public}s", key.c_str());
1293     if (AAFwk::Array::IsStringArray(ao)) {
1294         return InnerWrapWantParamsArray<AAFwk::IString, AAFwk::String, std::string>(
1295             env, object, key, ao);
1296     } else if (AAFwk::Array::IsBooleanArray(ao)) {
1297         return InnerWrapWantParamsArray<AAFwk::IBoolean, AAFwk::Boolean, bool>(
1298             env, object, key, ao);
1299     } else if (AAFwk::Array::IsShortArray(ao)) {
1300         return InnerWrapWantParamsArray<AAFwk::IShort, AAFwk::Short, short>(
1301             env, object, key, ao);
1302     } else if (AAFwk::Array::IsIntegerArray(ao)) {
1303         return InnerWrapWantParamsArray<AAFwk::IInteger, AAFwk::Integer, int>(
1304             env, object, key, ao);
1305     } else if (AAFwk::Array::IsLongArray(ao)) {
1306         return InnerWrapWantParamsArray<AAFwk::ILong, AAFwk::Long, int64_t>(
1307             env, object, key, ao);
1308     } else if (AAFwk::Array::IsFloatArray(ao)) {
1309         return InnerWrapWantParamsArray<AAFwk::IFloat, AAFwk::Float, float>(
1310             env, object, key, ao);
1311     } else if (AAFwk::Array::IsByteArray(ao)) {
1312         return InnerWrapWantParamsArray<AAFwk::IByte, AAFwk::Byte, int>(
1313             env, object, key, ao);
1314     } else if (AAFwk::Array::IsCharArray(ao)) {
1315         return InnerWrapWantParamsArray<AAFwk::IChar, AAFwk::Char, char>(
1316             env, object, key, ao);
1317     } else if (AAFwk::Array::IsDoubleArray(ao)) {
1318         return InnerWrapWantParamsArray<AAFwk::IDouble, AAFwk::Double, double>(
1319             env, object, key, ao);
1320     } else if (AAFwk::Array::IsWantParamsArray(ao)) {
1321         TAG_LOGD(AAFwkTag::JSNAPI, "Array type is WantParams");
1322         return InnerWrapWantParamsArrayWantParams(env, object, key, ao);
1323     } else {
1324         TAG_LOGE(AAFwkTag::JSNAPI, "Array type unknown");
1325         return false;
1326     }
1327 }
1328 }  // namespace AppExecFwk
1329 }  // namespace OHOS
1330