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_message_parcel.h"
17 #include <cstring>
18 #include <unistd.h>
19 #include "hilog/log.h"
20 #include "log_tags.h"
21 #include "napi_ashmem.h"
22 #include "napi_remote_object.h"
23 #include "napi_rpc_common.h"
24 #include "string_ex.h"
25 #include "ipc_debug.h"
26 
27 namespace OHOS {
28 using namespace OHOS::HiviewDFX;
29 
30 static constexpr OHOS::HiviewDFX::HiLogLabel LOG_LABEL = { LOG_CORE, LOG_ID_IPC_NAPI, "Napi_MessageParcelWrite" };
31 
NAPI_MessageParcel(napi_env env,napi_value thisVar,MessageParcel * parcel)32 NAPI_MessageParcel::NAPI_MessageParcel(napi_env env, napi_value thisVar, MessageParcel *parcel)
33 {
34     env_ = env;
35     maxCapacityToWrite_ = MAX_CAPACITY_TO_WRITE;
36     // do NOT reference js parcel here
37     if (parcel == nullptr) {
38         nativeParcel_ = std::make_shared<MessageParcel>();
39         owner = true;
40     } else {
41         nativeParcel_ = std::shared_ptr<MessageParcel>(parcel, release);
42         owner = false;
43     }
44 }
45 
~NAPI_MessageParcel()46 NAPI_MessageParcel::~NAPI_MessageParcel()
47 {
48     ZLOGD(LOG_LABEL, "NAPI_MessageParcel::Destructor");
49     nativeParcel_ = nullptr;
50     env_ = nullptr;
51 }
52 
release(MessageParcel * parcel)53 void NAPI_MessageParcel::release(MessageParcel *parcel)
54 {
55     ZLOGD(LOG_LABEL, "message parcel is created by others, do nothing");
56 }
57 
GetMessageParcel()58 std::shared_ptr<MessageParcel> NAPI_MessageParcel::GetMessageParcel()
59 {
60     return nativeParcel_;
61 }
62 
JS_writeByte(napi_env env,napi_callback_info info)63 napi_value NAPI_MessageParcel::JS_writeByte(napi_env env, napi_callback_info info)
64 {
65     size_t argc = 1;
66     napi_value argv[ARGV_LENGTH_1] = {0};
67     napi_value thisVar = nullptr;
68     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
69     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
70 
71     napi_valuetype valueType = napi_null;
72     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
73     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
74 
75     int32_t value = 0;
76     napi_get_value_int32(env, argv[ARGV_INDEX_0], &value);
77 
78     NAPI_MessageParcel *napiParcel = nullptr;
79     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
80     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
81     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
82     bool result = napiParcel->nativeParcel_->WriteInt8(static_cast<int8_t>(value));
83     napi_value napiValue = nullptr;
84     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
85     return napiValue;
86 }
87 
JS_writeShort(napi_env env,napi_callback_info info)88 napi_value NAPI_MessageParcel::JS_writeShort(napi_env env, napi_callback_info info)
89 {
90     size_t argc = 1;
91     napi_value argv[ARGV_LENGTH_1] = {0};
92     napi_value thisVar = nullptr;
93     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
94     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
95 
96     napi_valuetype valueType = napi_null;
97     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
98     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
99 
100     int32_t value = 0;
101     napi_get_value_int32(env, argv[ARGV_INDEX_0], &value);
102 
103     NAPI_MessageParcel *napiParcel = nullptr;
104     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
105     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
106     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
107     bool result = napiParcel->nativeParcel_->WriteInt16(static_cast<int16_t>(value));
108     napi_value napiValue = nullptr;
109     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
110     return napiValue;
111 }
112 
JS_writeInt(napi_env env,napi_callback_info info)113 napi_value NAPI_MessageParcel::JS_writeInt(napi_env env, napi_callback_info info)
114 {
115     size_t argc = 1;
116     napi_value argv[ARGV_LENGTH_1] = {0};
117     napi_value thisVar = nullptr;
118     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
119     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
120 
121     napi_valuetype valueType = napi_null;
122     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
123     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
124 
125     int32_t value = 0;
126     napi_get_value_int32(env, argv[ARGV_INDEX_0], &value);
127 
128     NAPI_MessageParcel *napiParcel = nullptr;
129     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
130     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
131     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
132     bool result = napiParcel->nativeParcel_->WriteInt32(value);
133     napi_value napiValue = nullptr;
134     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
135     return napiValue;
136 }
137 
JS_writeLong(napi_env env,napi_callback_info info)138 napi_value NAPI_MessageParcel::JS_writeLong(napi_env env, napi_callback_info info)
139 {
140     size_t argc = 1;
141     napi_value argv[ARGV_LENGTH_1] = {0};
142     napi_value thisVar = nullptr;
143     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
144     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
145 
146     napi_valuetype valueType = napi_null;
147     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
148     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
149 
150     int64_t value = 0;
151     napi_get_value_int64(env, argv[ARGV_INDEX_0], &value);
152 
153     NAPI_MessageParcel *napiParcel = nullptr;
154     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
155     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
156     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_64, napiParcel);
157     bool result = napiParcel->nativeParcel_->WriteInt64(value);
158     napi_value napiValue = nullptr;
159     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
160     return napiValue;
161 }
162 
JS_writeFloat(napi_env env,napi_callback_info info)163 napi_value NAPI_MessageParcel::JS_writeFloat(napi_env env, napi_callback_info info)
164 {
165     size_t argc = 1;
166     napi_value argv[ARGV_LENGTH_1] = {0};
167     napi_value thisVar = nullptr;
168     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
169     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
170 
171     napi_valuetype valueType = napi_null;
172     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
173     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
174 
175     double value = 0;
176     napi_get_value_double(env, argv[ARGV_INDEX_0], &value);
177 
178     NAPI_MessageParcel *napiParcel = nullptr;
179     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
180     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
181     CHECK_WRITE_CAPACITY(env, sizeof(double), napiParcel);
182     bool result = napiParcel->nativeParcel_->WriteDouble(value);
183     napi_value napiValue = nullptr;
184     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
185     return napiValue;
186 }
187 
JS_writeDouble(napi_env env,napi_callback_info info)188 napi_value NAPI_MessageParcel::JS_writeDouble(napi_env env, napi_callback_info info)
189 {
190     size_t argc = 1;
191     napi_value argv[ARGV_LENGTH_1] = {0};
192     napi_value thisVar = nullptr;
193     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
194     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
195 
196     napi_valuetype valueType = napi_null;
197     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
198     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
199 
200     double value = 0;
201     napi_get_value_double(env, argv[ARGV_INDEX_0], &value);
202 
203     NAPI_MessageParcel *napiParcel = nullptr;
204     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
205     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
206     CHECK_WRITE_CAPACITY(env, sizeof(double), napiParcel);
207     bool result = napiParcel->nativeParcel_->WriteDouble(value);
208     napi_value napiValue = nullptr;
209     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
210     return napiValue;
211 }
212 
JS_writeBoolean(napi_env env,napi_callback_info info)213 napi_value NAPI_MessageParcel::JS_writeBoolean(napi_env env, napi_callback_info info)
214 {
215     size_t argc = 1;
216     napi_value argv[ARGV_LENGTH_1] = {0};
217     napi_value thisVar = nullptr;
218     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
219     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
220 
221     napi_valuetype valueType = napi_null;
222     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
223     NAPI_ASSERT(env, valueType == napi_boolean, "type mismatch for parameter 1");
224 
225     bool value = 0;
226     napi_get_value_bool(env, argv[ARGV_INDEX_0], &value);
227 
228     NAPI_MessageParcel *napiParcel = nullptr;
229     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
230     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
231     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
232     bool result = napiParcel->nativeParcel_->WriteInt8(static_cast<int8_t>(value));
233     napi_value napiValue = nullptr;
234     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
235     return napiValue;
236 }
237 
JS_writeChar(napi_env env,napi_callback_info info)238 napi_value NAPI_MessageParcel::JS_writeChar(napi_env env, napi_callback_info info)
239 {
240     size_t argc = 1;
241     napi_value argv[ARGV_LENGTH_1] = {0};
242     napi_value thisVar = nullptr;
243     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
244     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
245 
246     napi_valuetype valueType = napi_null;
247     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
248     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
249 
250     uint32_t value = 0;
251     napi_get_value_uint32(env, argv[ARGV_INDEX_0], &value);
252 
253     NAPI_MessageParcel *napiParcel = nullptr;
254     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
255     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
256     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
257     bool result = napiParcel->nativeParcel_->WriteUint8(static_cast<uint8_t>(value));
258     napi_value napiValue = nullptr;
259     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
260     return napiValue;
261 }
262 
JS_writeByteArray(napi_env env,napi_callback_info info)263 napi_value NAPI_MessageParcel::JS_writeByteArray(napi_env env, napi_callback_info info)
264 {
265     size_t argc = 1;
266     napi_value argv[ARGV_LENGTH_1] = {0};
267     napi_value thisVar = nullptr;
268     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
269     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
270 
271     bool isArray = false;
272     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
273     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
274 
275     uint32_t arrayLength = 0;
276     uint32_t maxBytesLen = 40960;
277     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
278     NAPI_ASSERT(env, arrayLength < maxBytesLen, "write byte array length too large");
279 
280     NAPI_MessageParcel *napiParcel = nullptr;
281     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
282     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
283 
284     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_8 * (arrayLength + 1), napiParcel);
285     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
286     napiParcel->nativeParcel_->WriteUint32(arrayLength);
287     bool result = false;
288     for (size_t i = 0; i < arrayLength; i++) {
289         bool hasElement = false;
290         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
291         NAPI_ASSERT(env, hasElement == true, "parameter check error");
292 
293         napi_value element = nullptr;
294         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
295 
296         int32_t value = 0;
297         napi_get_value_int32(env, element, &value);
298         result = napiParcel->nativeParcel_->WriteInt8(static_cast<int8_t>(value));
299         if (!result) {
300             napiParcel->nativeParcel_->RewindWrite(pos);
301             break;
302         }
303     }
304 
305     napi_value napiValue = nullptr;
306     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
307     return napiValue;
308 }
309 
JS_writeShortArray(napi_env env,napi_callback_info info)310 napi_value NAPI_MessageParcel::JS_writeShortArray(napi_env env, napi_callback_info info)
311 {
312     size_t argc = 1;
313     napi_value argv[ARGV_LENGTH_1] = { 0 };
314     napi_value thisVar = nullptr;
315     void *data = nullptr;
316     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
317     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
318 
319     bool isArray = false;
320     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
321     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
322 
323     uint32_t arrayLength = 0;
324     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
325 
326     NAPI_MessageParcel *napiParcel = nullptr;
327     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
328     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
329 
330     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * (arrayLength + 1), napiParcel);
331     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
332     napiParcel->nativeParcel_->WriteUint32(arrayLength);
333     bool result = false;
334     for (size_t i = 0; i < arrayLength; i++) {
335         bool hasElement = false;
336         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
337         NAPI_ASSERT(env, hasElement == true, "parameter check error");
338 
339         napi_value element = nullptr;
340         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
341 
342         int32_t value = 0;
343         napi_get_value_int32(env, element, &value);
344         result = napiParcel->nativeParcel_->WriteInt16(static_cast<int16_t>(value));
345         if (!result) {
346             napiParcel->nativeParcel_->RewindWrite(pos);
347             break;
348         }
349     }
350 
351     napi_value napiValue = nullptr;
352     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
353     return napiValue;
354 }
355 
JS_writeIntArray(napi_env env,napi_callback_info info)356 napi_value NAPI_MessageParcel::JS_writeIntArray(napi_env env, napi_callback_info info)
357 {
358     size_t argc = 1;
359     napi_value argv[ARGV_LENGTH_1] = { 0 };
360     napi_value thisVar = nullptr;
361     void *data = nullptr;
362     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
363     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
364 
365     bool isArray = false;
366     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
367     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
368 
369     uint32_t arrayLength = 0;
370     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
371 
372     NAPI_MessageParcel *napiParcel = nullptr;
373     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
374     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
375 
376     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * (arrayLength + 1), napiParcel);
377     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
378     napiParcel->nativeParcel_->WriteUint32(arrayLength);
379     bool result = false;
380     for (size_t i = 0; i < arrayLength; i++) {
381         bool hasElement = false;
382         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
383         NAPI_ASSERT(env, hasElement == true, "parameter check error");
384 
385         napi_value element = nullptr;
386         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
387 
388         napi_valuetype valueType;
389         napi_typeof(env, element, &valueType);
390         NAPI_ASSERT(env, valueType == napi_number, "type mismatch element");
391 
392         int32_t value = 0;
393         napi_get_value_int32(env, element, &value);
394         result = napiParcel->nativeParcel_->WriteInt32(value);
395         if (!result) {
396             napiParcel->nativeParcel_->RewindWrite(pos);
397             break;
398         }
399     }
400 
401     napi_value napiValue = nullptr;
402     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
403     return napiValue;
404 }
405 
JS_writeLongArray(napi_env env,napi_callback_info info)406 napi_value NAPI_MessageParcel::JS_writeLongArray(napi_env env, napi_callback_info info)
407 {
408     size_t argc = 1;
409     napi_value argv[ARGV_LENGTH_1] = { 0 };
410     napi_value thisVar = nullptr;
411     void *data = nullptr;
412     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
413     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
414 
415     bool isArray = false;
416     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
417     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
418 
419     uint32_t arrayLength = 0;
420     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
421     ZLOGI(LOG_LABEL, "messageparcel WriteBuffer typedarrayLength:%{public}d", (int)(arrayLength));
422 
423     NAPI_MessageParcel *napiParcel = nullptr;
424     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
425     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
426 
427     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 + BYTE_SIZE_64 * arrayLength, napiParcel);
428     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
429     napiParcel->nativeParcel_->WriteUint32(arrayLength);
430     bool result = false;
431     for (size_t i = 0; i < arrayLength; i++) {
432         bool hasElement = false;
433         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
434         NAPI_ASSERT(env, hasElement == true, "parameter check error");
435 
436         napi_value element = nullptr;
437         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
438 
439         int64_t value = 0;
440         napi_get_value_int64(env, element, &value);
441 
442         result = napiParcel->nativeParcel_->WriteInt64(value);
443         if (!result) {
444             napiParcel->nativeParcel_->RewindWrite(pos);
445             break;
446         }
447     }
448 
449     napi_value napiValue = nullptr;
450     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
451     return napiValue;
452 }
453 
JS_writeFloatArray(napi_env env,napi_callback_info info)454 napi_value NAPI_MessageParcel::JS_writeFloatArray(napi_env env, napi_callback_info info)
455 {
456     size_t argc = 1;
457     napi_value argv[ARGV_LENGTH_1] = { 0 };
458     napi_value thisVar = nullptr;
459     void *data = nullptr;
460     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
461     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
462 
463     bool isArray = false;
464     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
465     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
466 
467     uint32_t arrayLength = 0;
468     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
469 
470     NAPI_MessageParcel *napiParcel = nullptr;
471     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
472     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
473 
474     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 + sizeof(double) * arrayLength, napiParcel);
475     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
476     napiParcel->nativeParcel_->WriteUint32(arrayLength);
477     bool result = false;
478     for (size_t i = 0; i < arrayLength; i++) {
479         bool hasElement = false;
480         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
481         NAPI_ASSERT(env, hasElement == true, "parameter check error");
482 
483         napi_value element = nullptr;
484         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
485 
486         double value = 0;
487         napi_get_value_double(env, element, &value);
488 
489         result = napiParcel->nativeParcel_->WriteDouble(value);
490         if (!result) {
491             napiParcel->nativeParcel_->RewindWrite(pos);
492             break;
493         }
494     }
495 
496     napi_value napiValue = nullptr;
497     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
498     return napiValue;
499 }
500 
JS_writeDoubleArray(napi_env env,napi_callback_info info)501 napi_value NAPI_MessageParcel::JS_writeDoubleArray(napi_env env, napi_callback_info info)
502 {
503     size_t argc = 1;
504     napi_value argv[ARGV_LENGTH_1] = { 0 };
505     napi_value thisVar = nullptr;
506     void *data = nullptr;
507     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
508     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
509 
510     bool isArray = false;
511     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
512     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
513 
514     uint32_t arrayLength = 0;
515     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
516 
517     NAPI_MessageParcel *napiParcel = nullptr;
518     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
519     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
520 
521     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 + sizeof(double) * arrayLength, napiParcel);
522     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
523     napiParcel->nativeParcel_->WriteUint32(arrayLength);
524     bool result = false;
525     for (size_t i = 0; i < arrayLength; i++) {
526         bool hasElement = false;
527         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
528         NAPI_ASSERT(env, hasElement == true, "parameter check error");
529 
530         napi_value element = nullptr;
531         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
532 
533         double value = 0;
534         napi_get_value_double(env, element, &value);
535 
536         result = napiParcel->nativeParcel_->WriteDouble(value);
537         if (!result) {
538             napiParcel->nativeParcel_->RewindWrite(pos);
539             break;
540         }
541     }
542 
543     napi_value napiValue = nullptr;
544     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
545     return napiValue;
546 }
547 
JS_writeBooleanArray(napi_env env,napi_callback_info info)548 napi_value NAPI_MessageParcel::JS_writeBooleanArray(napi_env env, napi_callback_info info)
549 {
550     size_t argc = 1;
551     napi_value argv[ARGV_LENGTH_1] = { 0 };
552     napi_value thisVar = nullptr;
553     void *data = nullptr;
554     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
555     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
556 
557     bool isArray = false;
558     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
559     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
560 
561     uint32_t arrayLength = 0;
562     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
563 
564     NAPI_MessageParcel *napiParcel = nullptr;
565     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
566     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
567 
568     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * (arrayLength + 1), napiParcel);
569     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
570     napiParcel->nativeParcel_->WriteUint32(arrayLength);
571     bool result = false;
572     for (size_t i = 0; i < arrayLength; i++) {
573         bool hasElement = false;
574         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
575         NAPI_ASSERT(env, hasElement == true, "parameter check error");
576 
577         napi_value element = nullptr;
578         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
579 
580         bool value = 0;
581         napi_get_value_bool(env, element, &value);
582 
583         result = napiParcel->nativeParcel_->WriteInt8(static_cast<int8_t>(value));
584         if (!result) {
585             napiParcel->nativeParcel_->RewindWrite(pos);
586             break;
587         }
588     }
589 
590     napi_value napiValue = nullptr;
591     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
592     return napiValue;
593 }
594 
JS_writeCharArray(napi_env env,napi_callback_info info)595 napi_value NAPI_MessageParcel::JS_writeCharArray(napi_env env, napi_callback_info info)
596 {
597     size_t argc = 1;
598     napi_value argv[ARGV_LENGTH_1] = { 0 };
599     napi_value thisVar = nullptr;
600     void *data = nullptr;
601     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
602     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
603 
604     bool isArray = false;
605     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
606     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
607 
608     uint32_t arrayLength = 0;
609     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
610 
611     NAPI_MessageParcel *napiParcel = nullptr;
612     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
613     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
614 
615     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * (arrayLength + 1), napiParcel);
616     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
617     napiParcel->nativeParcel_->WriteUint32(arrayLength);
618     bool result = false;
619     for (size_t i = 0; i < arrayLength; i++) {
620         bool hasElement = false;
621         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
622         NAPI_ASSERT(env, hasElement == true, "parameter check error");
623 
624         napi_value element = nullptr;
625         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
626         uint32_t value = 0;
627         napi_get_value_uint32(env, element, &value);
628 
629         result = napiParcel->nativeParcel_->WriteUint8(static_cast<uint8_t>(value));
630         if (!result) {
631             napiParcel->nativeParcel_->RewindWrite(pos);
632             break;
633         }
634     }
635 
636     napi_value napiValue = nullptr;
637     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
638     return napiValue;
639 }
640 
JS_writeString(napi_env env,napi_callback_info info)641 napi_value NAPI_MessageParcel::JS_writeString(napi_env env, napi_callback_info info)
642 {
643     size_t argc = 1;
644     napi_value argv[ARGV_LENGTH_1] = {0};
645     napi_value thisVar = nullptr;
646     void *data = nullptr;
647     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
648     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
649 
650     NAPI_MessageParcel *napiParcel = nullptr;
651     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
652     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
653 
654     napi_valuetype valueType = napi_null;
655     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
656     NAPI_ASSERT(env, valueType == napi_string, "type mismatch for parameter 1");
657 
658     size_t bufferSize = 0;
659     size_t maxLen = 40960;
660     napi_get_value_string_utf8(env, argv[ARGV_INDEX_0], nullptr, 0, &bufferSize);
661     NAPI_ASSERT(env, bufferSize < maxLen, "string length too large");
662 
663     char stringValue[bufferSize + 1];
664     size_t jsStringLength = 0;
665     napi_get_value_string_utf8(env, argv[ARGV_INDEX_0], stringValue, bufferSize + 1, &jsStringLength);
666     NAPI_ASSERT(env, jsStringLength == bufferSize, "string length wrong");
667 
668     CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * bufferSize, napiParcel);
669     std::string parcelString = stringValue;
670     bool result = napiParcel->nativeParcel_->WriteString16(to_utf16(parcelString));
671 
672     napi_value napiValue = nullptr;
673     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
674     return napiValue;
675 }
676 
JS_writeStringArray(napi_env env,napi_callback_info info)677 napi_value NAPI_MessageParcel::JS_writeStringArray(napi_env env, napi_callback_info info)
678 {
679     size_t argc = 1;
680     napi_value argv[ARGV_LENGTH_1] = { 0 };
681     napi_value thisVar = nullptr;
682     void *data = nullptr;
683     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
684     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
685 
686     bool isArray = false;
687     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
688     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
689 
690     uint32_t arrayLength = 0;
691     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
692 
693     NAPI_MessageParcel *napiParcel = nullptr;
694     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
695     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
696 
697     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
698     napiParcel->nativeParcel_->WriteUint32(arrayLength);
699     bool result = false;
700     for (size_t i = 0; i < arrayLength; i++) {
701         bool hasElement = false;
702         size_t maxSize = 40960;
703         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
704         NAPI_ASSERT(env, hasElement == true, "parameter check error");
705 
706         napi_value element = nullptr;
707         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
708         napi_valuetype valuetype;
709         napi_typeof(env, element, &valuetype);
710         NAPI_ASSERT(env, valuetype == napi_string, "Parameter type error");
711 
712         size_t bufferSize = 0;
713         napi_get_value_string_utf8(env, element, nullptr, 0, &bufferSize);
714         NAPI_ASSERT(env, bufferSize < maxSize, "string length too large");
715 
716         char stringValue[bufferSize + 1];
717         size_t jsStringLength = 0;
718         napi_get_value_string_utf8(env, element, stringValue, bufferSize + 1, &jsStringLength);
719         NAPI_ASSERT(env, jsStringLength == bufferSize, "string length wrong");
720 
721         REWIND_IF_WRITE_CHECK_FAIL(env, BYTE_SIZE_32 * bufferSize, pos, napiParcel);
722         std::string parcelString = stringValue;
723         result = napiParcel->nativeParcel_->WriteString16(to_utf16(parcelString));
724         if (!result) {
725             napiParcel->nativeParcel_->RewindWrite(pos);
726             break;
727         }
728     }
729 
730     napi_value napiValue = nullptr;
731     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
732     return napiValue;
733 }
734 
JS_writeSequenceable(napi_env env,napi_callback_info info)735 napi_value NAPI_MessageParcel::JS_writeSequenceable(napi_env env, napi_callback_info info)
736 {
737     napi_value result = nullptr;
738     napi_get_boolean(env, false, &result);
739 
740     size_t argc = 1;
741     napi_value argv[ARGV_LENGTH_1] = { 0 };
742     napi_value thisVar = nullptr;
743     void *data = nullptr;
744     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
745     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
746 
747     NAPI_MessageParcel *napiParcel = nullptr;
748     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
749     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
750 
751     napi_valuetype valueType = napi_null;
752     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
753     if (valueType == napi_null || valueType == napi_undefined) {
754         napiParcel->nativeParcel_->WriteInt32(0);
755         return result;
756     }
757     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
758     napiParcel->nativeParcel_->WriteInt32(1);
759     napi_value propKey = nullptr;
760     const char *propKeyStr = "marshalling";
761     napi_create_string_utf8(env, propKeyStr, strlen(propKeyStr), &propKey);
762     napi_value prop = nullptr;
763     napi_get_property(env, argv[ARGV_INDEX_0], propKey, &prop);
764 
765     napi_value funcArg[1] = { thisVar };
766     napi_value callResult = nullptr;
767     napi_call_function(env, argv[ARGV_INDEX_0], prop, 1, funcArg, &callResult);
768     napi_typeof(env, callResult, &valueType);
769     if (callResult != nullptr && valueType != napi_undefined) {
770         return callResult;
771     }
772     ZLOGE(LOG_LABEL, "call mashalling failed");
773     napiParcel->nativeParcel_->RewindWrite(pos);
774     return result;
775 }
776 
JS_writeSequenceableArray(napi_env env,napi_callback_info info)777 napi_value NAPI_MessageParcel::JS_writeSequenceableArray(napi_env env, napi_callback_info info)
778 {
779     napi_value retValue = nullptr;
780     napi_get_boolean(env, false, &retValue);
781 
782     size_t argc = 1;
783     napi_value argv[ARGV_LENGTH_1] = { 0 };
784     napi_value thisVar = nullptr;
785     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
786     NAPI_ASSERT_BASE(env, argc == 1, "requires 1 parameter", retValue);
787 
788     bool isArray = false;
789     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
790     NAPI_ASSERT_BASE(env, isArray == true, "type mismatch for parameter 1", retValue);
791     uint32_t arrayLength = 0;
792     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
793 
794     NAPI_MessageParcel *napiParcel = nullptr;
795     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
796     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", retValue);
797 
798     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
799     bool result = napiParcel->nativeParcel_->WriteUint32(arrayLength);
800     for (size_t i = 0; i < arrayLength; i++) {
801         bool hasElement = false;
802         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
803         NAPI_ASSERT_BASE(env, hasElement == true, "parameter check error", retValue);
804 
805         napi_value element = nullptr;
806         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
807         napi_valuetype valueType = napi_null;
808         napi_typeof(env, element, &valueType);
809         if (valueType == napi_null || valueType == napi_undefined) {
810             napiParcel->nativeParcel_->WriteInt32(0);
811             continue;
812         } else {
813             napiParcel->nativeParcel_->WriteInt32(1);
814         }
815         napi_value propKey = nullptr;
816         const char *propKeyStr = "marshalling";
817         napi_create_string_utf8(env, propKeyStr, strlen(propKeyStr), &propKey);
818         napi_value prop = nullptr;
819         napi_get_property(env, element, propKey, &prop);
820 
821         napi_value funcArg[1] = { thisVar };
822         napi_value callResult = nullptr;
823         napi_call_function(env, element, prop, 1, funcArg, &callResult);
824         napi_typeof(env, callResult, &valueType);
825         if (callResult == nullptr || valueType == napi_undefined) {
826             ZLOGE(LOG_LABEL, "call mashalling failed, element index:%{public}zu", i);
827             napiParcel->nativeParcel_->RewindWrite(pos);
828             return retValue;
829         }
830     }
831 
832     napi_get_boolean(env, result, &retValue);
833     return retValue;
834 }
835 
JS_writeRemoteObjectArray(napi_env env,napi_callback_info info)836 napi_value NAPI_MessageParcel::JS_writeRemoteObjectArray(napi_env env, napi_callback_info info)
837 {
838     napi_value retValue = nullptr;
839     napi_get_boolean(env, false, &retValue);
840 
841     size_t argc = 1;
842     napi_value argv[ARGV_LENGTH_1] = { 0 };
843     napi_value thisVar = nullptr;
844     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
845     NAPI_ASSERT_BASE(env, argc == 1, "requires 1 parameter", retValue);
846 
847     NAPI_MessageParcel *napiParcel = nullptr;
848     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
849     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", retValue);
850     napi_valuetype valueType = napi_null;
851     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
852     if (valueType == napi_null || valueType == napi_undefined) {
853         napiParcel->nativeParcel_->WriteInt32(-1);
854         return retValue;
855     }
856 
857     bool isArray = false;
858     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
859     NAPI_ASSERT_BASE(env, isArray == true, "type mismatch for parameter 1", retValue);
860 
861     uint32_t arrayLength = 0;
862     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
863     size_t pos = napiParcel->nativeParcel_->GetWritePosition();
864     bool result =  napiParcel->nativeParcel_->WriteInt32(arrayLength);
865     for (size_t i = 0; i < arrayLength; i++) {
866         bool hasElement = false;
867         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
868         NAPI_ASSERT_BASE(env, hasElement == true, "parameter check error", retValue);
869         napi_value element = nullptr;
870         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
871         sptr<IRemoteObject> remoteObject = NAPI_ohos_rpc_getNativeRemoteObject(env, element);
872         NAPI_ASSERT_BASE(env, remoteObject != nullptr, "parameter check error", retValue);
873         result = napiParcel->nativeParcel_->WriteRemoteObject(remoteObject);
874         if (!result) {
875             napiParcel->nativeParcel_->RewindWrite(pos);
876             return retValue;
877         }
878     }
879     napi_get_boolean(env, result, &retValue);
880     return retValue;
881 }
882 
JS_getSize(napi_env env,napi_callback_info info)883 napi_value NAPI_MessageParcel::JS_getSize(napi_env env, napi_callback_info info)
884 {
885     size_t argc = 0;
886     napi_value thisVar = nullptr;
887     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
888 
889     NAPI_MessageParcel *napiParcel = nullptr;
890     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
891     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
892 
893     size_t value = napiParcel->nativeParcel_->GetDataSize();
894     napi_value napiValue = nullptr;
895     NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(value), &napiValue));
896     return napiValue;
897 }
898 
JS_getCapacity(napi_env env,napi_callback_info info)899 napi_value NAPI_MessageParcel::JS_getCapacity(napi_env env, napi_callback_info info)
900 {
901     size_t argc = 0;
902     napi_value thisVar = nullptr;
903     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
904 
905     NAPI_MessageParcel *napiParcel = nullptr;
906     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
907     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
908 
909     size_t value = napiParcel->nativeParcel_->GetDataCapacity();
910     napi_value napiValue = nullptr;
911     NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(value), &napiValue));
912     return napiValue;
913 }
914 
JS_setSize(napi_env env,napi_callback_info info)915 napi_value NAPI_MessageParcel::JS_setSize(napi_env env, napi_callback_info info)
916 {
917     size_t argc = 1;
918     napi_value argv[ARGV_LENGTH_1] = {0};
919     napi_value thisVar = nullptr;
920     void *data = nullptr;
921     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
922     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
923 
924     napi_valuetype valueType = napi_null;
925     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
926     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
927 
928     uint32_t value = 0;
929     napi_get_value_uint32(env, argv[ARGV_INDEX_0], &value);
930 
931     NAPI_MessageParcel *napiParcel = nullptr;
932     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
933     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
934 
935     bool result = napiParcel->nativeParcel_->SetDataSize(static_cast<size_t>(value));
936     napi_value napiValue = nullptr;
937     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
938     return napiValue;
939 }
940 
JS_setCapacity(napi_env env,napi_callback_info info)941 napi_value NAPI_MessageParcel::JS_setCapacity(napi_env env, napi_callback_info info)
942 {
943     size_t argc = 1;
944     napi_value argv[ARGV_LENGTH_1] = {0};
945     napi_value thisVar = nullptr;
946     void *data = nullptr;
947     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
948     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
949 
950     napi_valuetype valueType = napi_null;
951     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
952     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
953 
954     uint32_t value = 0;
955     napi_get_value_uint32(env, argv[ARGV_INDEX_0], &value);
956 
957     NAPI_MessageParcel *napiParcel = nullptr;
958     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
959     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
960 
961     bool result = napiParcel->nativeParcel_->SetDataCapacity(static_cast<size_t>(value));
962     if (result) {
963         napiParcel->maxCapacityToWrite_ = value;
964     }
965     napi_value napiValue = nullptr;
966     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
967     return napiValue;
968 }
969 
JS_getWritableBytes(napi_env env,napi_callback_info info)970 napi_value NAPI_MessageParcel::JS_getWritableBytes(napi_env env, napi_callback_info info)
971 {
972     size_t argc = 0;
973     napi_value thisVar = nullptr;
974     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
975 
976     NAPI_MessageParcel *napiParcel = nullptr;
977     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
978     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
979 
980     size_t value = napiParcel->nativeParcel_->GetWritableBytes();
981     napi_value napiValue = nullptr;
982     NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(value), &napiValue));
983     return napiValue;
984 }
985 
JS_getReadableBytes(napi_env env,napi_callback_info info)986 napi_value NAPI_MessageParcel::JS_getReadableBytes(napi_env env, napi_callback_info info)
987 {
988     size_t argc = 0;
989     napi_value thisVar = nullptr;
990     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
991 
992     NAPI_MessageParcel *napiParcel = nullptr;
993     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
994     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
995 
996     size_t value = napiParcel->nativeParcel_->GetReadableBytes();
997     napi_value napiValue = nullptr;
998     NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(value), &napiValue));
999     return napiValue;
1000 }
1001 
JS_getReadPosition(napi_env env,napi_callback_info info)1002 napi_value NAPI_MessageParcel::JS_getReadPosition(napi_env env, napi_callback_info info)
1003 {
1004     size_t argc = 0;
1005     napi_value thisVar = nullptr;
1006     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1007 
1008     NAPI_MessageParcel *napiParcel = nullptr;
1009     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1010     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1011 
1012     size_t value = napiParcel->nativeParcel_->GetReadPosition();
1013     napi_value napiValue = nullptr;
1014     NAPI_CALL(env, napi_create_uint32(env, value, &napiValue));
1015     return napiValue;
1016 }
1017 
JS_rewindRead(napi_env env,napi_callback_info info)1018 napi_value NAPI_MessageParcel::JS_rewindRead(napi_env env, napi_callback_info info)
1019 {
1020     size_t argc = 1;
1021     napi_value argv[ARGV_LENGTH_1] = {0};
1022     napi_value thisVar = nullptr;
1023     void *data = nullptr;
1024     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1025     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1026 
1027     napi_valuetype valueType = napi_null;
1028     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1029     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
1030 
1031     uint32_t pos = 0;
1032     napi_get_value_uint32(env, argv[ARGV_INDEX_0], &pos);
1033 
1034     NAPI_MessageParcel *napiParcel = nullptr;
1035     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1036     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1037 
1038     bool result = napiParcel->nativeParcel_->RewindRead(static_cast<size_t>(pos));
1039     napi_value napiValue = nullptr;
1040     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1041     return napiValue;
1042 }
1043 
JS_getWritePosition(napi_env env,napi_callback_info info)1044 napi_value NAPI_MessageParcel::JS_getWritePosition(napi_env env, napi_callback_info info)
1045 {
1046     size_t argc = 0;
1047     napi_value thisVar = nullptr;
1048     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1049 
1050     NAPI_MessageParcel *napiParcel = nullptr;
1051     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1052     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1053 
1054     size_t value = napiParcel->nativeParcel_->GetWritePosition();
1055     napi_value napiValue = nullptr;
1056     NAPI_CALL(env, napi_create_uint32(env, value, &napiValue));
1057     return napiValue;
1058 }
1059 
JS_rewindWrite(napi_env env,napi_callback_info info)1060 napi_value NAPI_MessageParcel::JS_rewindWrite(napi_env env, napi_callback_info info)
1061 {
1062     size_t argc = 1;
1063     napi_value argv[ARGV_LENGTH_1] = {0};
1064     napi_value thisVar = nullptr;
1065     void *data = nullptr;
1066     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1067     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1068 
1069     napi_valuetype valueType = napi_null;
1070     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1071     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
1072 
1073     uint32_t pos = 0;
1074     napi_get_value_uint32(env, argv[ARGV_INDEX_0], &pos);
1075 
1076     NAPI_MessageParcel *napiParcel = nullptr;
1077     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1078     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1079 
1080     bool result = napiParcel->nativeParcel_->RewindWrite(static_cast<size_t>(pos));
1081     napi_value napiValue = nullptr;
1082     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1083     return napiValue;
1084 }
1085 
JS_writeNoException(napi_env env,napi_callback_info info)1086 napi_value NAPI_MessageParcel::JS_writeNoException(napi_env env, napi_callback_info info)
1087 {
1088     napi_value thisVar = nullptr;
1089     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1090     NAPI_MessageParcel *napiParcel = nullptr;
1091     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1092     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1093     napiParcel->nativeParcel_->WriteInt32(0);
1094     napi_value result = nullptr;
1095     napi_get_undefined(env, &result);
1096     return result;
1097 }
1098 
JS_create(napi_env env,napi_callback_info info)1099 napi_value NAPI_MessageParcel::JS_create(napi_env env, napi_callback_info info)
1100 {
1101     // new native parcel object
1102     napi_value global = nullptr;
1103     napi_status status = napi_get_global(env, &global);
1104     NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
1105     napi_value constructor = nullptr;
1106     status = napi_get_named_property(env, global, "IPCParcelConstructor_", &constructor);
1107     NAPI_ASSERT(env, status == napi_ok, "get message parcel constructor failed");
1108     napi_value jsMessageParcel;
1109     status = napi_new_instance(env, constructor, 0, nullptr, &jsMessageParcel);
1110     NAPI_ASSERT(env, status == napi_ok, "failed to  construct js MessageParcel");
1111     return jsMessageParcel;
1112 }
1113 
JS_reclaim(napi_env env,napi_callback_info info)1114 napi_value NAPI_MessageParcel::JS_reclaim(napi_env env, napi_callback_info info)
1115 {
1116     size_t argc = 0;
1117     napi_value thisVar = nullptr;
1118     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1119 
1120     NAPI_MessageParcel *napiParcel = nullptr;
1121     napi_remove_wrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1122     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1123     delete napiParcel;
1124 
1125     napi_value result = nullptr;
1126     napi_get_undefined(env, &result);
1127     return result;
1128 }
1129 
JS_writeRemoteObject(napi_env env,napi_callback_info info)1130 napi_value NAPI_MessageParcel::JS_writeRemoteObject(napi_env env, napi_callback_info info)
1131 {
1132     size_t argc = 1;
1133     napi_value argv[ARGV_LENGTH_1] = { 0 };
1134     napi_value thisVar = nullptr;
1135     void *data = nullptr;
1136     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1137     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1138     napi_valuetype valueType = napi_null;
1139     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1140     napi_value napiValue = nullptr;
1141     if (valueType != napi_object) {
1142         napi_get_boolean(env, false, &napiValue);
1143         return napiValue;
1144     }
1145     sptr<IRemoteObject> remoteObject = NAPI_ohos_rpc_getNativeRemoteObject(env, argv[ARGV_INDEX_0]);
1146     if (remoteObject == nullptr) {
1147         napi_get_boolean(env, false, &napiValue);
1148         return napiValue;
1149     }
1150     NAPI_MessageParcel *napiParcel = nullptr;
1151     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1152     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1153     bool result = napiParcel->nativeParcel_->WriteRemoteObject(remoteObject);
1154     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1155     return napiValue;
1156 }
1157 
JS_writeInterfaceToken(napi_env env,napi_callback_info info)1158 napi_value NAPI_MessageParcel::JS_writeInterfaceToken(napi_env env, napi_callback_info info)
1159 {
1160     size_t argc = 1;
1161     napi_value argv[ARGV_LENGTH_1] = { 0 };
1162     napi_value thisVar = nullptr;
1163     void *data = nullptr;
1164     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1165     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1166 
1167     napi_valuetype valueType = napi_null;
1168     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1169     NAPI_ASSERT(env, valueType == napi_string, "type mismatch for parameter");
1170 
1171     size_t bufferSize = 0;
1172     size_t maxSize = 40960;
1173     napi_get_value_string_utf8(env, argv[ARGV_INDEX_0], nullptr, 0, &bufferSize);
1174     NAPI_ASSERT(env, bufferSize < maxSize, "string length too large");
1175 
1176     char stringValue[bufferSize + 1];
1177     size_t jsStringLength = 0;
1178     napi_get_value_string_utf8(env, argv[ARGV_INDEX_0], stringValue, bufferSize + 1, &jsStringLength);
1179     NAPI_ASSERT(env, jsStringLength == bufferSize, "string length wrong");
1180 
1181     NAPI_MessageParcel *napiParcel = nullptr;
1182     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1183     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1184 
1185     std::string parcelString = stringValue;
1186     bool result = napiParcel->nativeParcel_->WriteInterfaceToken(to_utf16(parcelString));
1187 
1188     napi_value napiValue = nullptr;
1189     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1190     return napiValue;
1191 }
1192 
JS_CloseFileDescriptor(napi_env env,napi_callback_info info)1193 napi_value NAPI_MessageParcel::JS_CloseFileDescriptor(napi_env env, napi_callback_info info)
1194 {
1195     size_t argc = 1;
1196     napi_value argv[ARGV_LENGTH_1] = { 0 };
1197     napi_value thisVar = nullptr;
1198     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1199     NAPI_ASSERT(env, argc == 1, "requires 1 parameters");
1200     napi_valuetype valueType = napi_null;
1201     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1202     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
1203     int32_t fd = -1;
1204     napi_get_value_int32(env, argv[ARGV_INDEX_0], &fd);
1205     close(fd);
1206     napi_value result = nullptr;
1207     napi_get_undefined(env, &result);
1208     return result;
1209 }
1210 
JS_DupFileDescriptor(napi_env env,napi_callback_info info)1211 napi_value NAPI_MessageParcel::JS_DupFileDescriptor(napi_env env, napi_callback_info info)
1212 {
1213     size_t argc = 1;
1214     napi_value argv[ARGV_LENGTH_1] = { 0 };
1215     napi_value thisVar = nullptr;
1216     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1217     NAPI_ASSERT(env, argc == 1, "requires 1 parameters");
1218     napi_valuetype valueType = napi_null;
1219     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1220     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
1221     int32_t fd = -1;
1222     napi_get_value_int32(env, argv[ARGV_INDEX_0], &fd);
1223     int32_t dupResult = dup(fd);
1224     napi_value napiValue;
1225     napi_create_int32(env, dupResult, &napiValue);
1226     return napiValue;
1227 }
1228 
JS_ContainFileDescriptors(napi_env env,napi_callback_info info)1229 napi_value NAPI_MessageParcel::JS_ContainFileDescriptors(napi_env env, napi_callback_info info)
1230 {
1231     size_t argc = 0;
1232     napi_value thisVar = nullptr;
1233     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1234     NAPI_MessageParcel *napiParcel = nullptr;
1235     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1236     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1237     bool result = napiParcel->nativeParcel_->ContainFileDescriptors();
1238     napi_value napiValue = nullptr;
1239     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1240     return napiValue;
1241 }
1242 
JS_WriteFileDescriptor(napi_env env,napi_callback_info info)1243 napi_value NAPI_MessageParcel::JS_WriteFileDescriptor(napi_env env, napi_callback_info info)
1244 {
1245     size_t argc = 1;
1246     napi_value argv[ARGV_LENGTH_1] = { 0 };
1247     napi_value thisVar = nullptr;
1248     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1249     NAPI_ASSERT(env, argc == 1, "requires 1 parameters");
1250     napi_valuetype valueType = napi_null;
1251     napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1252     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
1253     int32_t fd = -1;
1254     napi_get_value_int32(env, argv[ARGV_INDEX_0], &fd);
1255     NAPI_MessageParcel *napiParcel = nullptr;
1256     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1257     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1258     bool result = napiParcel->nativeParcel_->WriteFileDescriptor(fd);
1259     napi_value napiValue = nullptr;
1260     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1261     return napiValue;
1262 }
1263 
JS_WriteAshmem(napi_env env,napi_callback_info info)1264 napi_value NAPI_MessageParcel::JS_WriteAshmem(napi_env env, napi_callback_info info)
1265 {
1266     size_t argc = 1;
1267     napi_value argv[ARGV_LENGTH_1] = { 0 };
1268     napi_value thisVar = nullptr;
1269     void *data = nullptr;
1270     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1271     NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1272     // check type is Ashmem
1273     napi_value global = nullptr;
1274     napi_status status = napi_get_global(env, &global);
1275     NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
1276     napi_value constructor = nullptr;
1277     status = napi_get_named_property(env, global, "AshmemConstructor_", &constructor);
1278     NAPI_ASSERT(env, status == napi_ok, "get Ashmem constructor failed");
1279     bool isAshmem = false;
1280     napi_instanceof(env, argv[ARGV_INDEX_0], constructor, &isAshmem);
1281     NAPI_ASSERT(env, isAshmem == true, "parameter is not instanceof Ashmem");
1282     NAPIAshmem *napiAshmem = nullptr;
1283     napi_unwrap(env, argv[ARGV_INDEX_0], reinterpret_cast<void **>(&napiAshmem));
1284     NAPI_ASSERT(env, napiAshmem != nullptr, "napiAshmem is null");
1285     sptr<Ashmem> nativeAshmem = napiAshmem->GetAshmem();
1286     NAPI_MessageParcel *napiParcel = nullptr;
1287     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1288     NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1289     bool result = napiParcel->nativeParcel_->WriteAshmem(nativeAshmem);
1290     napi_value napiValue = nullptr;
1291     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1292     return napiValue;
1293 }
1294 
JS_WriteRawData(napi_env env,napi_callback_info info)1295 napi_value NAPI_MessageParcel::JS_WriteRawData(napi_env env, napi_callback_info info)
1296 {
1297     size_t argc = 2;
1298     napi_value argv[ARGV_LENGTH_2] = {0};
1299     napi_value thisVar = nullptr;
1300     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1301     NAPI_ASSERT(env, argc == ARGV_LENGTH_2, "requires 2 parameter");
1302     bool isArray = false;
1303     napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1304     NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1305 
1306     std::vector<int32_t> array;
1307     uint32_t arrayLength = 0;
1308     napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
1309 
1310     for (size_t i = 0; i < arrayLength; i++) {
1311         bool hasElement = false;
1312         napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
1313         NAPI_ASSERT(env, hasElement == true, "parameter check error");
1314 
1315         napi_value element = nullptr;
1316         napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
1317 
1318         int32_t value = 0;
1319         napi_get_value_int32(env, element, &value);
1320         array.push_back(value);
1321     }
1322 
1323     napi_valuetype valueType = napi_null;
1324     napi_typeof(env, argv[ARGV_INDEX_1], &valueType);
1325     NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 2");
1326     int32_t size = 0;
1327     napi_get_value_int32(env, argv[ARGV_INDEX_1], &size);
1328     NAPI_MessageParcel *napiParcel = nullptr;
1329     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1330     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1331     bool result = napiParcel->nativeParcel_->WriteRawData(array.data(), size * BYTE_SIZE_32);
1332     napi_value napiValue = nullptr;
1333     NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1334     return napiValue;
1335 }
1336 
JS_GetRawDataCapacity(napi_env env,napi_callback_info info)1337 napi_value NAPI_MessageParcel::JS_GetRawDataCapacity(napi_env env, napi_callback_info info)
1338 {
1339     size_t argc = 0;
1340     napi_value thisVar = nullptr;
1341     napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1342     NAPI_MessageParcel *napiParcel = nullptr;
1343     napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1344     NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1345     uint32_t result = napiParcel->nativeParcel_->GetRawDataCapacity();
1346     napi_value napiValue;
1347     napi_create_uint32(env, result, &napiValue);
1348     return napiValue;
1349 }
1350 
Export(napi_env env,napi_value exports)1351 napi_value NAPI_MessageParcel::Export(napi_env env, napi_value exports)
1352 {
1353     const std::string className = "MessageParcel";
1354     napi_property_descriptor properties[] = {
1355         DECLARE_NAPI_STATIC_FUNCTION("create", NAPI_MessageParcel::JS_create),
1356         DECLARE_NAPI_FUNCTION("reclaim", NAPI_MessageParcel::JS_reclaim),
1357         DECLARE_NAPI_FUNCTION("writeRemoteObject", NAPI_MessageParcel::JS_writeRemoteObject),
1358         DECLARE_NAPI_FUNCTION("readRemoteObject", NAPI_MessageParcel::JS_readRemoteObject),
1359         DECLARE_NAPI_FUNCTION("writeInterfaceToken", NAPI_MessageParcel::JS_writeInterfaceToken),
1360         DECLARE_NAPI_FUNCTION("readInterfaceToken", NAPI_MessageParcel::JS_readInterfaceToken),
1361         DECLARE_NAPI_FUNCTION("getSize", NAPI_MessageParcel::JS_getSize),
1362         DECLARE_NAPI_FUNCTION("getCapacity", NAPI_MessageParcel::JS_getCapacity),
1363         DECLARE_NAPI_FUNCTION("setSize", NAPI_MessageParcel::JS_setSize),
1364         DECLARE_NAPI_FUNCTION("setCapacity", NAPI_MessageParcel::JS_setCapacity),
1365         DECLARE_NAPI_FUNCTION("getWritableBytes", NAPI_MessageParcel::JS_getWritableBytes),
1366         DECLARE_NAPI_FUNCTION("getReadableBytes", NAPI_MessageParcel::JS_getReadableBytes),
1367         DECLARE_NAPI_FUNCTION("getReadPosition", NAPI_MessageParcel::JS_getReadPosition),
1368         DECLARE_NAPI_FUNCTION("getWritePosition", NAPI_MessageParcel::JS_getWritePosition),
1369         DECLARE_NAPI_FUNCTION("rewindRead", NAPI_MessageParcel::JS_rewindRead),
1370         DECLARE_NAPI_FUNCTION("rewindWrite", NAPI_MessageParcel::JS_rewindWrite),
1371         DECLARE_NAPI_FUNCTION("writeNoException", NAPI_MessageParcel::JS_writeNoException),
1372         DECLARE_NAPI_FUNCTION("readException", NAPI_MessageParcel::JS_readException),
1373         DECLARE_NAPI_FUNCTION("writeByte", NAPI_MessageParcel::JS_writeByte),
1374         DECLARE_NAPI_FUNCTION("writeShort", NAPI_MessageParcel::JS_writeShort),
1375         DECLARE_NAPI_FUNCTION("writeInt", NAPI_MessageParcel::JS_writeInt),
1376         DECLARE_NAPI_FUNCTION("writeLong", NAPI_MessageParcel::JS_writeLong),
1377         DECLARE_NAPI_FUNCTION("writeFloat", NAPI_MessageParcel::JS_writeFloat),
1378         DECLARE_NAPI_FUNCTION("writeDouble", NAPI_MessageParcel::JS_writeDouble),
1379         DECLARE_NAPI_FUNCTION("writeBoolean", NAPI_MessageParcel::JS_writeBoolean),
1380         DECLARE_NAPI_FUNCTION("writeChar", NAPI_MessageParcel::JS_writeChar),
1381         DECLARE_NAPI_FUNCTION("writeString", NAPI_MessageParcel::JS_writeString),
1382         DECLARE_NAPI_FUNCTION("writeSequenceable", NAPI_MessageParcel::JS_writeSequenceable),
1383         DECLARE_NAPI_FUNCTION("writeByteArray", NAPI_MessageParcel::JS_writeByteArray),
1384         DECLARE_NAPI_FUNCTION("writeShortArray", NAPI_MessageParcel::JS_writeShortArray),
1385         DECLARE_NAPI_FUNCTION("writeIntArray", NAPI_MessageParcel::JS_writeIntArray),
1386         DECLARE_NAPI_FUNCTION("writeLongArray", NAPI_MessageParcel::JS_writeLongArray),
1387         DECLARE_NAPI_FUNCTION("writeFloatArray", NAPI_MessageParcel::JS_writeFloatArray),
1388         DECLARE_NAPI_FUNCTION("writeDoubleArray", NAPI_MessageParcel::JS_writeDoubleArray),
1389         DECLARE_NAPI_FUNCTION("writeBooleanArray", NAPI_MessageParcel::JS_writeBooleanArray),
1390         DECLARE_NAPI_FUNCTION("writeCharArray", NAPI_MessageParcel::JS_writeCharArray),
1391         DECLARE_NAPI_FUNCTION("writeStringArray", NAPI_MessageParcel::JS_writeStringArray),
1392         DECLARE_NAPI_FUNCTION("writeSequenceableArray", NAPI_MessageParcel::JS_writeSequenceableArray),
1393         DECLARE_NAPI_FUNCTION("writeRemoteObjectArray", NAPI_MessageParcel::JS_writeRemoteObjectArray),
1394         DECLARE_NAPI_FUNCTION("readByte", NAPI_MessageParcel::JS_readByte),
1395         DECLARE_NAPI_FUNCTION("readShort", NAPI_MessageParcel::JS_readShort),
1396         DECLARE_NAPI_FUNCTION("readInt", NAPI_MessageParcel::JS_readInt),
1397         DECLARE_NAPI_FUNCTION("readLong", NAPI_MessageParcel::JS_readLong),
1398         DECLARE_NAPI_FUNCTION("readFloat", NAPI_MessageParcel::JS_readFloat),
1399         DECLARE_NAPI_FUNCTION("readDouble", NAPI_MessageParcel::JS_readDouble),
1400         DECLARE_NAPI_FUNCTION("readBoolean", NAPI_MessageParcel::JS_readBoolean),
1401         DECLARE_NAPI_FUNCTION("readChar", NAPI_MessageParcel::JS_readChar),
1402         DECLARE_NAPI_FUNCTION("readString", NAPI_MessageParcel::JS_readString),
1403         DECLARE_NAPI_FUNCTION("readSequenceable", NAPI_MessageParcel::JS_readSequenceable),
1404         DECLARE_NAPI_FUNCTION("readByteArray", NAPI_MessageParcel::JS_readByteArray),
1405         DECLARE_NAPI_FUNCTION("readShortArray", NAPI_MessageParcel::JS_readShortArray),
1406         DECLARE_NAPI_FUNCTION("readIntArray", NAPI_MessageParcel::JS_readIntArray),
1407         DECLARE_NAPI_FUNCTION("readLongArray", NAPI_MessageParcel::JS_readLongArray),
1408         DECLARE_NAPI_FUNCTION("readFloatArray", NAPI_MessageParcel::JS_readFloatArray),
1409         DECLARE_NAPI_FUNCTION("readDoubleArray", NAPI_MessageParcel::JS_readDoubleArray),
1410         DECLARE_NAPI_FUNCTION("readBooleanArray", NAPI_MessageParcel::JS_readBooleanArray),
1411         DECLARE_NAPI_FUNCTION("readCharArray", NAPI_MessageParcel::JS_readCharArray),
1412         DECLARE_NAPI_FUNCTION("readStringArray", NAPI_MessageParcel::JS_readStringArray),
1413         DECLARE_NAPI_FUNCTION("readSequenceableArray", NAPI_MessageParcel::JS_readSequenceableArray),
1414         DECLARE_NAPI_FUNCTION("readRemoteObjectArray", NAPI_MessageParcel::JS_readRemoteObjectArray),
1415         DECLARE_NAPI_STATIC_FUNCTION("closeFileDescriptor", NAPI_MessageParcel::JS_CloseFileDescriptor),
1416         DECLARE_NAPI_STATIC_FUNCTION("dupFileDescriptor", NAPI_MessageParcel::JS_DupFileDescriptor),
1417         DECLARE_NAPI_FUNCTION("writeFileDescriptor", NAPI_MessageParcel::JS_WriteFileDescriptor),
1418         DECLARE_NAPI_FUNCTION("readFileDescriptor", NAPI_MessageParcel::JS_ReadFileDescriptor),
1419         DECLARE_NAPI_FUNCTION("containFileDescriptors", NAPI_MessageParcel::JS_ContainFileDescriptors),
1420         DECLARE_NAPI_FUNCTION("writeAshmem", NAPI_MessageParcel::JS_WriteAshmem),
1421         DECLARE_NAPI_FUNCTION("readAshmem", NAPI_MessageParcel::JS_ReadAshmem),
1422         DECLARE_NAPI_FUNCTION("getRawDataCapacity", NAPI_MessageParcel::JS_GetRawDataCapacity),
1423         DECLARE_NAPI_FUNCTION("writeRawData", NAPI_MessageParcel::JS_WriteRawData),
1424         DECLARE_NAPI_FUNCTION("readRawData", NAPI_MessageParcel::JS_ReadRawData),
1425     };
1426     napi_value constructor = nullptr;
1427     napi_define_class(env, className.c_str(), className.length(), JS_constructor, nullptr,
1428         sizeof(properties) / sizeof(properties[0]), properties, &constructor);
1429     NAPI_ASSERT(env, constructor != nullptr, "define js class MessageParcel failed");
1430     napi_status status = napi_set_named_property(env, exports, "MessageParcel", constructor);
1431     NAPI_ASSERT(env, status == napi_ok, "set property MessageParcel failed");
1432     napi_value global = nullptr;
1433     status = napi_get_global(env, &global);
1434     NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
1435     status = napi_set_named_property(env, global, "IPCParcelConstructor_", constructor);
1436     NAPI_ASSERT(env, status == napi_ok, "set message parcel constructor failed");
1437     return exports;
1438 }
1439 
JS_constructor(napi_env env,napi_callback_info info)1440 napi_value NAPI_MessageParcel::JS_constructor(napi_env env, napi_callback_info info)
1441 {
1442     napi_value thisVar = nullptr;
1443     size_t argc = 1;
1444     napi_value argv[ARGV_LENGTH_1] = { 0 };
1445     napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1446     NAPI_ASSERT(env, status == napi_ok, "napi get callback info failed");
1447     MessageParcel *parcel = nullptr;
1448     if (argc > 0) {
1449         napi_unwrap(env, argv[ARGV_INDEX_0], reinterpret_cast<void **>(&parcel));
1450         NAPI_ASSERT(env, parcel != nullptr, "parcel is null");
1451     }
1452     // new native parcel object
1453     auto messageParcel = new (std::nothrow) NAPI_MessageParcel(env, thisVar, parcel);
1454     NAPI_ASSERT(env, messageParcel != nullptr, "new messageParcel failed");
1455     // connect native object to js thisVar
1456     status = napi_wrap(
1457         env, thisVar, messageParcel,
1458         [](napi_env env, void *data, void *hint) {
1459             NAPI_MessageParcel *messageParcel = reinterpret_cast<NAPI_MessageParcel *>(data);
1460             if (!messageParcel->owner) {
1461                 delete messageParcel;
1462             }
1463         },
1464         nullptr, nullptr);
1465     if (status != napi_ok) {
1466         delete messageParcel;
1467         NAPI_ASSERT(env, false, "napi wrap message parcel failed");
1468     }
1469     return thisVar;
1470 }
1471 } // namespace OHOS
1472