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