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 "string_ex.h"
24 #include "ipc_debug.h"
25
26
27 namespace OHOS {
28 using namespace OHOS::HiviewDFX;
29 constexpr size_t MAX_CAPACITY_TO_WRITE = 200 * 1024;
30 constexpr size_t BYTE_SIZE_8 = 1;
31 constexpr size_t BYTE_SIZE_32 = 4;
32 constexpr size_t BYTE_SIZE_64 = 8;
33
34 static const size_t ARGV_INDEX_0 = 0;
35 static const size_t ARGV_INDEX_1 = 1;
36
37 static const size_t ARGV_LENGTH_1 = 1;
38 static const size_t ARGV_LENGTH_2 = 2;
39 static constexpr OHOS::HiviewDFX::HiLogLabel LOG_LABEL = { LOG_CORE, LOG_ID_IPC_NAPI, "napi_messageParcel" };
40
41 #define CHECK_WRITE_CAPACITY(env, lenToWrite, napiParcel) \
42 do { \
43 size_t cap = napiParcel->maxCapacityToWrite_ - napiParcel->nativeParcel_->GetWritePosition(); \
44 if (cap < (lenToWrite)) { \
45 ZLOGI(LOG_LABEL, "No enough capacity to write"); \
46 napi_throw_range_error(env, nullptr, "No enough capacity to write"); \
47 } \
48 } while (0)
49
50 #define REWIND_IF_WRITE_CHECK_FAIL(env, lenToWrite, pos, napiParcel) \
51 do { \
52 size_t cap = napiParcel->maxCapacityToWrite_ - napiParcel->nativeParcel_->GetWritePosition(); \
53 if (cap < (lenToWrite)) { \
54 ZLOGI(LOG_LABEL, "No enough capacity to write"); \
55 napiParcel->nativeParcel_->RewindWrite(pos); \
56 napi_throw_range_error(env, nullptr, "No enough capacity to write"); \
57 } \
58 } while (0)
59
60 #define CHECK_READ_LENGTH(env, arrayLength, typeSize, napiParcel) \
61 do { \
62 size_t remainSize = napiParcel->nativeParcel_->GetDataSize() - napiParcel->nativeParcel_->GetReadPosition(); \
63 if (((arrayLength) < 0) || ((arrayLength) > remainSize) || (((arrayLength) * (typeSize)) > remainSize)) { \
64 ZLOGI(LOG_LABEL, "No enough data to read"); \
65 napi_throw_range_error(env, nullptr, "No enough data to read"); \
66 } \
67 } while (0)
68
NAPI_MessageParcel(napi_env env,napi_value thisVar,MessageParcel * parcel)69 NAPI_MessageParcel::NAPI_MessageParcel(napi_env env, napi_value thisVar, MessageParcel *parcel)
70 {
71 env_ = env;
72 maxCapacityToWrite_ = MAX_CAPACITY_TO_WRITE;
73 // do NOT reference js parcel here
74 if (parcel == nullptr) {
75 nativeParcel_ = std::shared_ptr<MessageParcel>(new MessageParcel());
76 owner = true;
77 } else {
78 nativeParcel_ = std::shared_ptr<MessageParcel>(parcel, release);
79 owner = false;
80 }
81 }
82
~NAPI_MessageParcel()83 NAPI_MessageParcel::~NAPI_MessageParcel()
84 {
85 ZLOGI(LOG_LABEL, "NAPI_MessageParcel::Destructor");
86 nativeParcel_ = nullptr;
87 env_ = nullptr;
88 }
89
release(MessageParcel * parcel)90 void NAPI_MessageParcel::release(MessageParcel *parcel)
91 {
92 ZLOGI(LOG_LABEL, "message parcel is created by others, do nothing");
93 }
94
GetMessageParcel()95 std::shared_ptr<MessageParcel> NAPI_MessageParcel::GetMessageParcel()
96 {
97 return nativeParcel_;
98 }
99
JS_writeByte(napi_env env,napi_callback_info info)100 napi_value NAPI_MessageParcel::JS_writeByte(napi_env env, napi_callback_info info)
101 {
102 size_t argc = 1;
103 napi_value argv[ARGV_LENGTH_1] = {0};
104 napi_value thisVar = nullptr;
105 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
106 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
107
108 napi_valuetype valueType = napi_null;
109 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
110 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
111
112 int32_t value = 0;
113 napi_get_value_int32(env, argv[ARGV_INDEX_0], &value);
114
115 NAPI_MessageParcel *napiParcel = nullptr;
116 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
117 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
118 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
119 bool result = napiParcel->nativeParcel_->WriteInt8(static_cast<int8_t>(value));
120 napi_value napiValue = nullptr;
121 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
122 return napiValue;
123 }
124
JS_writeShort(napi_env env,napi_callback_info info)125 napi_value NAPI_MessageParcel::JS_writeShort(napi_env env, napi_callback_info info)
126 {
127 size_t argc = 1;
128 napi_value argv[ARGV_LENGTH_1] = {0};
129 napi_value thisVar = nullptr;
130 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
131 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
132
133 napi_valuetype valueType = napi_null;
134 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
135 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
136
137 int32_t value = 0;
138 napi_get_value_int32(env, argv[ARGV_INDEX_0], &value);
139
140 NAPI_MessageParcel *napiParcel = nullptr;
141 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
142 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
143 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
144 bool result = napiParcel->nativeParcel_->WriteInt16(static_cast<int16_t>(value));
145 napi_value napiValue = nullptr;
146 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
147 return napiValue;
148 }
149
JS_writeInt(napi_env env,napi_callback_info info)150 napi_value NAPI_MessageParcel::JS_writeInt(napi_env env, napi_callback_info info)
151 {
152 size_t argc = 1;
153 napi_value argv[ARGV_LENGTH_1] = {0};
154 napi_value thisVar = nullptr;
155 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
156 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
157
158 napi_valuetype valueType = napi_null;
159 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
160 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
161
162 int32_t value = 0;
163 napi_get_value_int32(env, argv[ARGV_INDEX_0], &value);
164
165 NAPI_MessageParcel *napiParcel = nullptr;
166 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
167 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
168 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
169 bool result = napiParcel->nativeParcel_->WriteInt32(value);
170 napi_value napiValue = nullptr;
171 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
172 return napiValue;
173 }
174
JS_writeLong(napi_env env,napi_callback_info info)175 napi_value NAPI_MessageParcel::JS_writeLong(napi_env env, napi_callback_info info)
176 {
177 size_t argc = 1;
178 napi_value argv[ARGV_LENGTH_1] = {0};
179 napi_value thisVar = nullptr;
180 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
181 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
182
183 napi_valuetype valueType = napi_null;
184 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
185 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
186
187 int64_t value = 0;
188 napi_get_value_int64(env, argv[ARGV_INDEX_0], &value);
189
190 NAPI_MessageParcel *napiParcel = nullptr;
191 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
192 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
193 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_64, napiParcel);
194 bool result = napiParcel->nativeParcel_->WriteInt64(value);
195 napi_value napiValue = nullptr;
196 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
197 return napiValue;
198 }
199
JS_writeFloat(napi_env env,napi_callback_info info)200 napi_value NAPI_MessageParcel::JS_writeFloat(napi_env env, napi_callback_info info)
201 {
202 size_t argc = 1;
203 napi_value argv[ARGV_LENGTH_1] = {0};
204 napi_value thisVar = nullptr;
205 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
206 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
207
208 napi_valuetype valueType = napi_null;
209 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
210 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
211
212 double value = 0;
213 napi_get_value_double(env, argv[ARGV_INDEX_0], &value);
214
215 NAPI_MessageParcel *napiParcel = nullptr;
216 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
217 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
218 CHECK_WRITE_CAPACITY(env, sizeof(double), napiParcel);
219 bool result = napiParcel->nativeParcel_->WriteDouble(value);
220 napi_value napiValue = nullptr;
221 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
222 return napiValue;
223 }
224
JS_writeDouble(napi_env env,napi_callback_info info)225 napi_value NAPI_MessageParcel::JS_writeDouble(napi_env env, napi_callback_info info)
226 {
227 size_t argc = 1;
228 napi_value argv[ARGV_LENGTH_1] = {0};
229 napi_value thisVar = nullptr;
230 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
231 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
232
233 napi_valuetype valueType = napi_null;
234 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
235 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
236
237 double value = 0;
238 napi_get_value_double(env, argv[ARGV_INDEX_0], &value);
239
240 NAPI_MessageParcel *napiParcel = nullptr;
241 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
242 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
243 CHECK_WRITE_CAPACITY(env, sizeof(double), napiParcel);
244 bool result = napiParcel->nativeParcel_->WriteDouble(value);
245 napi_value napiValue = nullptr;
246 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
247 return napiValue;
248 }
249
JS_writeBoolean(napi_env env,napi_callback_info info)250 napi_value NAPI_MessageParcel::JS_writeBoolean(napi_env env, napi_callback_info info)
251 {
252 size_t argc = 1;
253 napi_value argv[ARGV_LENGTH_1] = {0};
254 napi_value thisVar = nullptr;
255 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
256 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
257
258 napi_valuetype valueType = napi_null;
259 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
260 NAPI_ASSERT(env, valueType == napi_boolean, "type mismatch for parameter 1");
261
262 bool value = 0;
263 napi_get_value_bool(env, argv[ARGV_INDEX_0], &value);
264
265 NAPI_MessageParcel *napiParcel = nullptr;
266 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
267 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
268 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
269 bool result = napiParcel->nativeParcel_->WriteInt8(static_cast<int8_t>(value));
270 napi_value napiValue = nullptr;
271 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
272 return napiValue;
273 }
274
JS_writeChar(napi_env env,napi_callback_info info)275 napi_value NAPI_MessageParcel::JS_writeChar(napi_env env, napi_callback_info info)
276 {
277 size_t argc = 1;
278 napi_value argv[ARGV_LENGTH_1] = {0};
279 napi_value thisVar = nullptr;
280 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
281 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
282
283 napi_valuetype valueType = napi_null;
284 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
285 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
286
287 uint32_t value = 0;
288 napi_get_value_uint32(env, argv[ARGV_INDEX_0], &value);
289
290 NAPI_MessageParcel *napiParcel = nullptr;
291 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
292 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
293 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32, napiParcel);
294 bool result = napiParcel->nativeParcel_->WriteUint8(static_cast<uint8_t>(value));
295 napi_value napiValue = nullptr;
296 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
297 return napiValue;
298 }
299
JS_writeByteArray(napi_env env,napi_callback_info info)300 napi_value NAPI_MessageParcel::JS_writeByteArray(napi_env env, napi_callback_info info)
301 {
302 size_t argc = 1;
303 napi_value argv[ARGV_LENGTH_1] = {0};
304 napi_value thisVar = nullptr;
305 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
306 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
307
308 bool isArray = false;
309 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
310 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
311
312 uint32_t arrayLength = 0;
313 uint32_t maxBytesLen = 40960;
314 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
315 NAPI_ASSERT(env, arrayLength < maxBytesLen, "write byte array length too large");
316
317 NAPI_MessageParcel *napiParcel = nullptr;
318 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
319 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
320
321 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_8 * (arrayLength + 1), napiParcel);
322 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
323 napiParcel->nativeParcel_->WriteUint32(arrayLength);
324 bool result = false;
325 for (size_t i = 0; i < arrayLength; i++) {
326 bool hasElement = false;
327 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
328 NAPI_ASSERT(env, hasElement == true, "parameter check error");
329
330 napi_value element = nullptr;
331 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
332
333 int32_t value = 0;
334 napi_get_value_int32(env, element, &value);
335 result = napiParcel->nativeParcel_->WriteInt8(static_cast<int8_t>(value));
336 if (!result) {
337 napiParcel->nativeParcel_->RewindWrite(pos);
338 break;
339 }
340 }
341
342 napi_value napiValue = nullptr;
343 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
344 return napiValue;
345 }
346
JS_writeShortArray(napi_env env,napi_callback_info info)347 napi_value NAPI_MessageParcel::JS_writeShortArray(napi_env env, napi_callback_info info)
348 {
349 size_t argc = 1;
350 napi_value argv[ARGV_LENGTH_1] = { 0 };
351 napi_value thisVar = nullptr;
352 void *data = nullptr;
353 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
354 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
355
356 bool isArray = false;
357 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
358 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
359
360 uint32_t arrayLength = 0;
361 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
362
363 NAPI_MessageParcel *napiParcel = nullptr;
364 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
365 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
366
367 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * (arrayLength + 1), napiParcel);
368 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
369 napiParcel->nativeParcel_->WriteUint32(arrayLength);
370 bool result = false;
371 for (size_t i = 0; i < arrayLength; i++) {
372 bool hasElement = false;
373 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
374 NAPI_ASSERT(env, hasElement == true, "parameter check error");
375
376 napi_value element = nullptr;
377 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
378
379 int32_t value = 0;
380 napi_get_value_int32(env, element, &value);
381 result = napiParcel->nativeParcel_->WriteInt16(static_cast<int16_t>(value));
382 if (!result) {
383 napiParcel->nativeParcel_->RewindWrite(pos);
384 break;
385 }
386 }
387
388 napi_value napiValue = nullptr;
389 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
390 return napiValue;
391 }
392
JS_writeIntArray(napi_env env,napi_callback_info info)393 napi_value NAPI_MessageParcel::JS_writeIntArray(napi_env env, napi_callback_info info)
394 {
395 size_t argc = 1;
396 napi_value argv[ARGV_LENGTH_1] = { 0 };
397 napi_value thisVar = nullptr;
398 void *data = nullptr;
399 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
400 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
401
402 bool isArray = false;
403 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
404 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
405
406 uint32_t arrayLength = 0;
407 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
408
409 NAPI_MessageParcel *napiParcel = nullptr;
410 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
411 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
412
413 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * (arrayLength + 1), napiParcel);
414 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
415 napiParcel->nativeParcel_->WriteUint32(arrayLength);
416 bool result = false;
417 for (size_t i = 0; i < arrayLength; i++) {
418 bool hasElement = false;
419 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
420 NAPI_ASSERT(env, hasElement == true, "parameter check error");
421
422 napi_value element = nullptr;
423 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
424
425 napi_valuetype valueType;
426 napi_typeof(env, element, &valueType);
427 NAPI_ASSERT(env, valueType == napi_number, "type mismatch element");
428
429 int32_t value = 0;
430 napi_get_value_int32(env, element, &value);
431 result = napiParcel->nativeParcel_->WriteInt32(value);
432 if (!result) {
433 napiParcel->nativeParcel_->RewindWrite(pos);
434 break;
435 }
436 }
437
438 napi_value napiValue = nullptr;
439 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
440 return napiValue;
441 }
442
JS_writeLongArray(napi_env env,napi_callback_info info)443 napi_value NAPI_MessageParcel::JS_writeLongArray(napi_env env, napi_callback_info info)
444 {
445 size_t argc = 1;
446 napi_value argv[ARGV_LENGTH_1] = { 0 };
447 napi_value thisVar = nullptr;
448 void *data = nullptr;
449 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
450 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
451
452 bool isArray = false;
453 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
454 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
455
456 uint32_t arrayLength = 0;
457 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
458 ZLOGI(LOG_LABEL, "messageparcel WriteBuffer typedarrayLength:%{public}d", (int)(arrayLength));
459
460 NAPI_MessageParcel *napiParcel = nullptr;
461 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
462 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
463
464 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 + BYTE_SIZE_64 * arrayLength, napiParcel);
465 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
466 napiParcel->nativeParcel_->WriteUint32(arrayLength);
467 bool result = false;
468 for (size_t i = 0; i < arrayLength; i++) {
469 bool hasElement = false;
470 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
471 NAPI_ASSERT(env, hasElement == true, "parameter check error");
472
473 napi_value element = nullptr;
474 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
475
476 int64_t value = 0;
477 napi_get_value_int64(env, element, &value);
478
479 result = napiParcel->nativeParcel_->WriteInt64(value);
480 if (!result) {
481 napiParcel->nativeParcel_->RewindWrite(pos);
482 break;
483 }
484 }
485
486 napi_value napiValue = nullptr;
487 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
488 return napiValue;
489 }
490
JS_writeFloatArray(napi_env env,napi_callback_info info)491 napi_value NAPI_MessageParcel::JS_writeFloatArray(napi_env env, napi_callback_info info)
492 {
493 size_t argc = 1;
494 napi_value argv[ARGV_LENGTH_1] = { 0 };
495 napi_value thisVar = nullptr;
496 void *data = nullptr;
497 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
498 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
499
500 bool isArray = false;
501 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
502 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
503
504 uint32_t arrayLength = 0;
505 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
506
507 NAPI_MessageParcel *napiParcel = nullptr;
508 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
509 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
510
511 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 + sizeof(double) * arrayLength, napiParcel);
512 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
513 napiParcel->nativeParcel_->WriteUint32(arrayLength);
514 bool result = false;
515 for (size_t i = 0; i < arrayLength; i++) {
516 bool hasElement = false;
517 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
518 NAPI_ASSERT(env, hasElement == true, "parameter check error");
519
520 napi_value element = nullptr;
521 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
522
523 double value = 0;
524 napi_get_value_double(env, element, &value);
525
526 result = napiParcel->nativeParcel_->WriteDouble(value);
527 if (!result) {
528 napiParcel->nativeParcel_->RewindWrite(pos);
529 break;
530 }
531 }
532
533 napi_value napiValue = nullptr;
534 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
535 return napiValue;
536 }
537
JS_writeDoubleArray(napi_env env,napi_callback_info info)538 napi_value NAPI_MessageParcel::JS_writeDoubleArray(napi_env env, napi_callback_info info)
539 {
540 size_t argc = 1;
541 napi_value argv[ARGV_LENGTH_1] = { 0 };
542 napi_value thisVar = nullptr;
543 void *data = nullptr;
544 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
545 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
546
547 bool isArray = false;
548 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
549 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
550
551 uint32_t arrayLength = 0;
552 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
553
554 NAPI_MessageParcel *napiParcel = nullptr;
555 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
556 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
557
558 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 + sizeof(double) * arrayLength, napiParcel);
559 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
560 napiParcel->nativeParcel_->WriteUint32(arrayLength);
561 bool result = false;
562 for (size_t i = 0; i < arrayLength; i++) {
563 bool hasElement = false;
564 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
565 NAPI_ASSERT(env, hasElement == true, "parameter check error");
566
567 napi_value element = nullptr;
568 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
569
570 double value = 0;
571 napi_get_value_double(env, element, &value);
572
573 result = napiParcel->nativeParcel_->WriteDouble(value);
574 if (!result) {
575 napiParcel->nativeParcel_->RewindWrite(pos);
576 break;
577 }
578 }
579
580 napi_value napiValue = nullptr;
581 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
582 return napiValue;
583 }
584
JS_writeBooleanArray(napi_env env,napi_callback_info info)585 napi_value NAPI_MessageParcel::JS_writeBooleanArray(napi_env env, napi_callback_info info)
586 {
587 size_t argc = 1;
588 napi_value argv[ARGV_LENGTH_1] = { 0 };
589 napi_value thisVar = nullptr;
590 void *data = nullptr;
591 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
592 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
593
594 bool isArray = false;
595 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
596 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
597
598 uint32_t arrayLength = 0;
599 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
600
601 NAPI_MessageParcel *napiParcel = nullptr;
602 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
603 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
604
605 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * (arrayLength + 1), napiParcel);
606 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
607 napiParcel->nativeParcel_->WriteUint32(arrayLength);
608 bool result = false;
609 for (size_t i = 0; i < arrayLength; i++) {
610 bool hasElement = false;
611 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
612 NAPI_ASSERT(env, hasElement == true, "parameter check error");
613
614 napi_value element = nullptr;
615 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
616
617 bool value = 0;
618 napi_get_value_bool(env, element, &value);
619
620 result = napiParcel->nativeParcel_->WriteInt8(static_cast<int8_t>(value));
621 if (!result) {
622 napiParcel->nativeParcel_->RewindWrite(pos);
623 break;
624 }
625 }
626
627 napi_value napiValue = nullptr;
628 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
629 return napiValue;
630 }
631
JS_writeCharArray(napi_env env,napi_callback_info info)632 napi_value NAPI_MessageParcel::JS_writeCharArray(napi_env env, napi_callback_info info)
633 {
634 size_t argc = 1;
635 napi_value argv[ARGV_LENGTH_1] = { 0 };
636 napi_value thisVar = nullptr;
637 void *data = nullptr;
638 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
639 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
640
641 bool isArray = false;
642 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
643 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
644
645 uint32_t arrayLength = 0;
646 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
647
648 NAPI_MessageParcel *napiParcel = nullptr;
649 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
650 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
651
652 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * (arrayLength + 1), napiParcel);
653 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
654 napiParcel->nativeParcel_->WriteUint32(arrayLength);
655 bool result = false;
656 for (size_t i = 0; i < arrayLength; i++) {
657 bool hasElement = false;
658 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
659 NAPI_ASSERT(env, hasElement == true, "parameter check error");
660
661 napi_value element = nullptr;
662 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
663 uint32_t value = 0;
664 napi_get_value_uint32(env, element, &value);
665
666 result = napiParcel->nativeParcel_->WriteUint8(static_cast<uint8_t>(value));
667 if (!result) {
668 napiParcel->nativeParcel_->RewindWrite(pos);
669 break;
670 }
671 }
672
673 napi_value napiValue = nullptr;
674 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
675 return napiValue;
676 }
677
JS_writeString(napi_env env,napi_callback_info info)678 napi_value NAPI_MessageParcel::JS_writeString(napi_env env, napi_callback_info info)
679 {
680 size_t argc = 1;
681 napi_value argv[ARGV_LENGTH_1] = {0};
682 napi_value thisVar = nullptr;
683 void *data = nullptr;
684 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
685 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
686
687 NAPI_MessageParcel *napiParcel = nullptr;
688 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
689 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
690
691 napi_valuetype valueType = napi_null;
692 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
693 NAPI_ASSERT(env, valueType == napi_string, "type mismatch for parameter 1");
694
695 size_t bufferSize = 0;
696 size_t maxLen = 40960;
697 napi_get_value_string_utf8(env, argv[ARGV_INDEX_0], nullptr, 0, &bufferSize);
698 NAPI_ASSERT(env, bufferSize < maxLen, "string length too large");
699
700 char stringValue[bufferSize + 1];
701 size_t jsStringLength = 0;
702 napi_get_value_string_utf8(env, argv[ARGV_INDEX_0], stringValue, bufferSize + 1, &jsStringLength);
703 NAPI_ASSERT(env, jsStringLength == bufferSize, "string length wrong");
704
705 CHECK_WRITE_CAPACITY(env, BYTE_SIZE_32 * bufferSize, napiParcel);
706 std::string parcelString = stringValue;
707 bool result = napiParcel->nativeParcel_->WriteString16(to_utf16(parcelString));
708
709 napi_value napiValue = nullptr;
710 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
711 return napiValue;
712 }
713
JS_writeStringArray(napi_env env,napi_callback_info info)714 napi_value NAPI_MessageParcel::JS_writeStringArray(napi_env env, napi_callback_info info)
715 {
716 size_t argc = 1;
717 napi_value argv[ARGV_LENGTH_1] = { 0 };
718 napi_value thisVar = nullptr;
719 void *data = nullptr;
720 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
721 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
722
723 bool isArray = false;
724 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
725 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
726
727 uint32_t arrayLength = 0;
728 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
729
730 NAPI_MessageParcel *napiParcel = nullptr;
731 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
732 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
733
734 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
735 napiParcel->nativeParcel_->WriteUint32(arrayLength);
736 bool result = false;
737 for (size_t i = 0; i < arrayLength; i++) {
738 bool hasElement = false;
739 size_t maxSize = 40960;
740 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
741 NAPI_ASSERT(env, hasElement == true, "parameter check error");
742
743 napi_value element = nullptr;
744 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
745 napi_valuetype valuetype;
746 napi_typeof(env, element, &valuetype);
747 NAPI_ASSERT(env, valuetype == napi_string, "Parameter type error");
748
749 size_t bufferSize = 0;
750 napi_get_value_string_utf8(env, element, nullptr, 0, &bufferSize);
751 NAPI_ASSERT(env, bufferSize < maxSize, "string length too large");
752
753 char stringValue[bufferSize + 1];
754 size_t jsStringLength = 0;
755 napi_get_value_string_utf8(env, element, stringValue, bufferSize + 1, &jsStringLength);
756 NAPI_ASSERT(env, jsStringLength == bufferSize, "string length wrong");
757
758 REWIND_IF_WRITE_CHECK_FAIL(env, BYTE_SIZE_32 * bufferSize, pos, napiParcel);
759 std::string parcelString = stringValue;
760 result = napiParcel->nativeParcel_->WriteString16(to_utf16(parcelString));
761 if (!result) {
762 napiParcel->nativeParcel_->RewindWrite(pos);
763 break;
764 }
765 }
766
767 napi_value napiValue = nullptr;
768 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
769 return napiValue;
770 }
771
JS_writeSequenceable(napi_env env,napi_callback_info info)772 napi_value NAPI_MessageParcel::JS_writeSequenceable(napi_env env, napi_callback_info info)
773 {
774 napi_value result = nullptr;
775 napi_get_boolean(env, false, &result);
776
777 size_t argc = 1;
778 napi_value argv[ARGV_LENGTH_1] = { 0 };
779 napi_value thisVar = nullptr;
780 void *data = nullptr;
781 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
782 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
783
784 NAPI_MessageParcel *napiParcel = nullptr;
785 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
786 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
787
788 napi_valuetype valueType = napi_null;
789 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
790 if (valueType == napi_null || valueType == napi_undefined) {
791 napiParcel->nativeParcel_->WriteInt32(0);
792 return result;
793 }
794 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
795 napiParcel->nativeParcel_->WriteInt32(1);
796 napi_value propKey = nullptr;
797 const char *propKeyStr = "marshalling";
798 napi_create_string_utf8(env, propKeyStr, strlen(propKeyStr), &propKey);
799 napi_value prop = nullptr;
800 napi_get_property(env, argv[ARGV_INDEX_0], propKey, &prop);
801
802 napi_value funcArg[1] = { thisVar };
803 napi_value callResult = nullptr;
804 napi_call_function(env, argv[ARGV_INDEX_0], prop, 1, funcArg, &callResult);
805 napi_typeof(env, callResult, &valueType);
806 if (callResult != nullptr && valueType != napi_undefined) {
807 return callResult;
808 }
809 ZLOGE(LOG_LABEL, "call mashalling failed");
810 napiParcel->nativeParcel_->RewindWrite(pos);
811 return result;
812 }
813
JS_writeSequenceableArray(napi_env env,napi_callback_info info)814 napi_value NAPI_MessageParcel::JS_writeSequenceableArray(napi_env env, napi_callback_info info)
815 {
816 napi_value retValue = nullptr;
817 napi_get_boolean(env, false, &retValue);
818
819 size_t argc = 1;
820 napi_value argv[ARGV_LENGTH_1] = { 0 };
821 napi_value thisVar = nullptr;
822 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
823 NAPI_ASSERT_BASE(env, argc == 1, "requires 1 parameter", retValue);
824
825 bool isArray = false;
826 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
827 NAPI_ASSERT_BASE(env, isArray == true, "type mismatch for parameter 1", retValue);
828 uint32_t arrayLength = 0;
829 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
830
831 NAPI_MessageParcel *napiParcel = nullptr;
832 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
833 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", retValue);
834
835 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
836 bool result = napiParcel->nativeParcel_->WriteUint32(arrayLength);
837 for (size_t i = 0; i < arrayLength; i++) {
838 bool hasElement = false;
839 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
840 NAPI_ASSERT_BASE(env, hasElement == true, "parameter check error", retValue);
841
842 napi_value element = nullptr;
843 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
844 napi_valuetype valueType = napi_null;
845 napi_typeof(env, element, &valueType);
846 if (valueType == napi_null || valueType == napi_undefined) {
847 napiParcel->nativeParcel_->WriteInt32(0);
848 continue;
849 } else {
850 napiParcel->nativeParcel_->WriteInt32(1);
851 }
852 napi_value propKey = nullptr;
853 const char *propKeyStr = "marshalling";
854 napi_create_string_utf8(env, propKeyStr, strlen(propKeyStr), &propKey);
855 napi_value prop = nullptr;
856 napi_get_property(env, element, propKey, &prop);
857
858 napi_value funcArg[1] = { thisVar };
859 napi_value callResult = nullptr;
860 napi_call_function(env, element, prop, 1, funcArg, &callResult);
861 napi_typeof(env, callResult, &valueType);
862 if (callResult == nullptr || valueType == napi_undefined) {
863 ZLOGE(LOG_LABEL, "call mashalling failed, element index:%{public}zu", i);
864 napiParcel->nativeParcel_->RewindWrite(pos);
865 return retValue;
866 }
867 }
868
869 napi_get_boolean(env, result, &retValue);
870 return retValue;
871 }
872
JS_writeRemoteObjectArray(napi_env env,napi_callback_info info)873 napi_value NAPI_MessageParcel::JS_writeRemoteObjectArray(napi_env env, napi_callback_info info)
874 {
875 napi_value retValue = nullptr;
876 napi_get_boolean(env, false, &retValue);
877
878 size_t argc = 1;
879 napi_value argv[ARGV_LENGTH_1] = { 0 };
880 napi_value thisVar = nullptr;
881 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
882 NAPI_ASSERT_BASE(env, argc == 1, "requires 1 parameter", retValue);
883
884 NAPI_MessageParcel *napiParcel = nullptr;
885 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
886 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", retValue);
887 napi_valuetype valueType = napi_null;
888 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
889 if (valueType == napi_null || valueType == napi_undefined) {
890 napiParcel->nativeParcel_->WriteInt32(-1);
891 return retValue;
892 }
893
894 bool isArray = false;
895 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
896 NAPI_ASSERT_BASE(env, isArray == true, "type mismatch for parameter 1", retValue);
897
898 uint32_t arrayLength = 0;
899 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
900 size_t pos = napiParcel->nativeParcel_->GetWritePosition();
901 bool result = napiParcel->nativeParcel_->WriteInt32(arrayLength);
902 for (size_t i = 0; i < arrayLength; i++) {
903 bool hasElement = false;
904 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
905 NAPI_ASSERT_BASE(env, hasElement == true, "parameter check error", retValue);
906 napi_value element = nullptr;
907 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
908 sptr<IRemoteObject> remoteObject = NAPI_ohos_rpc_getNativeRemoteObject(env, element);
909 NAPI_ASSERT_BASE(env, remoteObject != nullptr, "parameter check error", retValue);
910 result = napiParcel->nativeParcel_->WriteRemoteObject(remoteObject);
911 if (!result) {
912 napiParcel->nativeParcel_->RewindWrite(pos);
913 return retValue;
914 }
915 }
916 napi_get_boolean(env, result, &retValue);
917 return retValue;
918 }
919
JS_readByte(napi_env env,napi_callback_info info)920 napi_value NAPI_MessageParcel::JS_readByte(napi_env env, napi_callback_info info)
921 {
922 size_t argc = 0;
923 napi_value thisVar = nullptr;
924 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
925 NAPI_MessageParcel *napiParcel = nullptr;
926 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
927 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
928
929 int8_t value = napiParcel->nativeParcel_->ReadInt8();
930 napi_value napiValue = nullptr;
931 NAPI_CALL(env, napi_create_int32(env, value, &napiValue));
932 return napiValue;
933 }
934
JS_readShort(napi_env env,napi_callback_info info)935 napi_value NAPI_MessageParcel::JS_readShort(napi_env env, napi_callback_info info)
936 {
937 size_t argc = 0;
938 napi_value thisVar = nullptr;
939 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
940 NAPI_MessageParcel *napiParcel = nullptr;
941 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
942 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
943
944 int16_t value = napiParcel->nativeParcel_->ReadInt16();
945 napi_value napiValue = nullptr;
946 NAPI_CALL(env, napi_create_int32(env, value, &napiValue));
947 return napiValue;
948 }
949
JS_readInt(napi_env env,napi_callback_info info)950 napi_value NAPI_MessageParcel::JS_readInt(napi_env env, napi_callback_info info)
951 {
952 size_t argc = 0;
953 napi_value thisVar = nullptr;
954 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
955 NAPI_MessageParcel *napiParcel = nullptr;
956 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
957 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
958
959 int32_t value = napiParcel->nativeParcel_->ReadInt32();
960 napi_value napiValue = nullptr;
961 NAPI_CALL(env, napi_create_int32(env, value, &napiValue));
962 return napiValue;
963 }
964
JS_readLong(napi_env env,napi_callback_info info)965 napi_value NAPI_MessageParcel::JS_readLong(napi_env env, napi_callback_info info)
966 {
967 size_t argc = 0;
968 napi_value thisVar = nullptr;
969 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
970 NAPI_MessageParcel *napiParcel = nullptr;
971 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
972 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
973
974 int64_t value = napiParcel->nativeParcel_->ReadInt64();
975 napi_value napiValue = nullptr;
976 NAPI_CALL(env, napi_create_int64(env, value, &napiValue));
977 return napiValue;
978 }
979
JS_readFloat(napi_env env,napi_callback_info info)980 napi_value NAPI_MessageParcel::JS_readFloat(napi_env env, napi_callback_info info)
981 {
982 size_t argc = 0;
983 napi_value thisVar = nullptr;
984 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
985 NAPI_MessageParcel *napiParcel = nullptr;
986 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
987 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
988
989 double value = napiParcel->nativeParcel_->ReadDouble();
990 napi_value napiValue = nullptr;
991 NAPI_CALL(env, napi_create_double(env, value, &napiValue));
992 return napiValue;
993 }
994
JS_readDouble(napi_env env,napi_callback_info info)995 napi_value NAPI_MessageParcel::JS_readDouble(napi_env env, napi_callback_info info)
996 {
997 size_t argc = 0;
998 napi_value thisVar = nullptr;
999 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1000 NAPI_MessageParcel *napiParcel = nullptr;
1001 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1002 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1003
1004 double value = napiParcel->nativeParcel_->ReadDouble();
1005 napi_value napiValue = nullptr;
1006 NAPI_CALL(env, napi_create_double(env, value, &napiValue));
1007 return napiValue;
1008 }
1009
JS_readBoolean(napi_env env,napi_callback_info info)1010 napi_value NAPI_MessageParcel::JS_readBoolean(napi_env env, napi_callback_info info)
1011 {
1012 size_t argc = 0;
1013 napi_value thisVar = nullptr;
1014 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1015 NAPI_MessageParcel *napiParcel = nullptr;
1016 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1017 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1018
1019 int8_t value = napiParcel->nativeParcel_->ReadInt8();
1020 napi_value napiValue = nullptr;
1021 NAPI_CALL(env, napi_get_boolean(env, value, &napiValue));
1022 return napiValue;
1023 }
1024
JS_readChar(napi_env env,napi_callback_info info)1025 napi_value NAPI_MessageParcel::JS_readChar(napi_env env, napi_callback_info info)
1026 {
1027 size_t argc = 0;
1028 napi_value thisVar = nullptr;
1029 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1030 NAPI_MessageParcel *napiParcel = nullptr;
1031 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1032 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1033
1034 uint8_t value = napiParcel->nativeParcel_->ReadUint8();
1035 napi_value result = nullptr;
1036 napi_create_uint32(env, static_cast<uint32_t>(value), &result);
1037 return result;
1038 }
1039
JS_readString(napi_env env,napi_callback_info info)1040 napi_value NAPI_MessageParcel::JS_readString(napi_env env, napi_callback_info info)
1041 {
1042 size_t argc = 0;
1043 napi_value thisVar = nullptr;
1044 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1045 NAPI_MessageParcel *napiParcel = nullptr;
1046 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1047 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1048
1049 std::u16string parcelString = napiParcel->nativeParcel_->ReadString16();
1050 std::string outString = Str16ToStr8(parcelString.c_str());
1051 napi_value napiValue = nullptr;
1052 napi_create_string_utf8(env, outString.c_str(), outString.length(), &napiValue);
1053 return napiValue;
1054 }
1055
JS_getSize(napi_env env,napi_callback_info info)1056 napi_value NAPI_MessageParcel::JS_getSize(napi_env env, napi_callback_info info)
1057 {
1058 size_t argc = 0;
1059 napi_value thisVar = nullptr;
1060 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1061
1062 NAPI_MessageParcel *napiParcel = nullptr;
1063 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1064 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1065
1066 size_t value = napiParcel->nativeParcel_->GetDataSize();
1067 napi_value napiValue = nullptr;
1068 NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(value), &napiValue));
1069 return napiValue;
1070 }
1071
JS_getCapacity(napi_env env,napi_callback_info info)1072 napi_value NAPI_MessageParcel::JS_getCapacity(napi_env env, napi_callback_info info)
1073 {
1074 size_t argc = 0;
1075 napi_value thisVar = nullptr;
1076 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1077
1078 NAPI_MessageParcel *napiParcel = nullptr;
1079 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1080 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1081
1082 size_t value = napiParcel->nativeParcel_->GetDataCapacity();
1083 napi_value napiValue = nullptr;
1084 NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(value), &napiValue));
1085 return napiValue;
1086 }
1087
JS_setSize(napi_env env,napi_callback_info info)1088 napi_value NAPI_MessageParcel::JS_setSize(napi_env env, napi_callback_info info)
1089 {
1090 size_t argc = 1;
1091 napi_value argv[ARGV_LENGTH_1] = {0};
1092 napi_value thisVar = nullptr;
1093 void *data = nullptr;
1094 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1095 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1096
1097 napi_valuetype valueType = napi_null;
1098 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1099 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
1100
1101 uint32_t value = 0;
1102 napi_get_value_uint32(env, argv[ARGV_INDEX_0], &value);
1103
1104 NAPI_MessageParcel *napiParcel = nullptr;
1105 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1106 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1107
1108 bool result = napiParcel->nativeParcel_->SetDataSize(static_cast<size_t>(value));
1109 napi_value napiValue = nullptr;
1110 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1111 return napiValue;
1112 }
1113
JS_setCapacity(napi_env env,napi_callback_info info)1114 napi_value NAPI_MessageParcel::JS_setCapacity(napi_env env, napi_callback_info info)
1115 {
1116 size_t argc = 1;
1117 napi_value argv[ARGV_LENGTH_1] = {0};
1118 napi_value thisVar = nullptr;
1119 void *data = nullptr;
1120 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1121 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1122
1123 napi_valuetype valueType = napi_null;
1124 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1125 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
1126
1127 uint32_t value = 0;
1128 napi_get_value_uint32(env, argv[ARGV_INDEX_0], &value);
1129
1130 NAPI_MessageParcel *napiParcel = nullptr;
1131 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1132 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1133
1134 bool result = napiParcel->nativeParcel_->SetDataCapacity(static_cast<size_t>(value));
1135 if (result) {
1136 napiParcel->maxCapacityToWrite_ = value;
1137 }
1138 napi_value napiValue = nullptr;
1139 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1140 return napiValue;
1141 }
1142
JS_getWritableBytes(napi_env env,napi_callback_info info)1143 napi_value NAPI_MessageParcel::JS_getWritableBytes(napi_env env, napi_callback_info info)
1144 {
1145 size_t argc = 0;
1146 napi_value thisVar = nullptr;
1147 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1148
1149 NAPI_MessageParcel *napiParcel = nullptr;
1150 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1151 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1152
1153 size_t value = napiParcel->nativeParcel_->GetWritableBytes();
1154 napi_value napiValue = nullptr;
1155 NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(value), &napiValue));
1156 return napiValue;
1157 }
1158
JS_getReadableBytes(napi_env env,napi_callback_info info)1159 napi_value NAPI_MessageParcel::JS_getReadableBytes(napi_env env, napi_callback_info info)
1160 {
1161 size_t argc = 0;
1162 napi_value thisVar = nullptr;
1163 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1164
1165 NAPI_MessageParcel *napiParcel = nullptr;
1166 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1167 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1168
1169 size_t value = napiParcel->nativeParcel_->GetReadableBytes();
1170 napi_value napiValue = nullptr;
1171 NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(value), &napiValue));
1172 return napiValue;
1173 }
1174
JS_getReadPosition(napi_env env,napi_callback_info info)1175 napi_value NAPI_MessageParcel::JS_getReadPosition(napi_env env, napi_callback_info info)
1176 {
1177 size_t argc = 0;
1178 napi_value thisVar = nullptr;
1179 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1180
1181 NAPI_MessageParcel *napiParcel = nullptr;
1182 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1183 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1184
1185 size_t value = napiParcel->nativeParcel_->GetReadPosition();
1186 napi_value napiValue = nullptr;
1187 NAPI_CALL(env, napi_create_uint32(env, value, &napiValue));
1188 return napiValue;
1189 }
1190
JS_rewindRead(napi_env env,napi_callback_info info)1191 napi_value NAPI_MessageParcel::JS_rewindRead(napi_env env, napi_callback_info info)
1192 {
1193 size_t argc = 1;
1194 napi_value argv[ARGV_LENGTH_1] = {0};
1195 napi_value thisVar = nullptr;
1196 void *data = nullptr;
1197 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1198 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1199
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
1204 uint32_t pos = 0;
1205 napi_get_value_uint32(env, argv[ARGV_INDEX_0], &pos);
1206
1207 NAPI_MessageParcel *napiParcel = nullptr;
1208 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1209 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1210
1211 bool result = napiParcel->nativeParcel_->RewindRead(static_cast<size_t>(pos));
1212 napi_value napiValue = nullptr;
1213 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1214 return napiValue;
1215 }
1216
JS_getWritePosition(napi_env env,napi_callback_info info)1217 napi_value NAPI_MessageParcel::JS_getWritePosition(napi_env env, napi_callback_info info)
1218 {
1219 size_t argc = 0;
1220 napi_value thisVar = nullptr;
1221 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1222
1223 NAPI_MessageParcel *napiParcel = nullptr;
1224 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1225 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1226
1227 size_t value = napiParcel->nativeParcel_->GetWritePosition();
1228 napi_value napiValue = nullptr;
1229 NAPI_CALL(env, napi_create_uint32(env, value, &napiValue));
1230 return napiValue;
1231 }
1232
JS_rewindWrite(napi_env env,napi_callback_info info)1233 napi_value NAPI_MessageParcel::JS_rewindWrite(napi_env env, napi_callback_info info)
1234 {
1235 size_t argc = 1;
1236 napi_value argv[ARGV_LENGTH_1] = {0};
1237 napi_value thisVar = nullptr;
1238 void *data = nullptr;
1239 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1240 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1241
1242 napi_valuetype valueType = napi_null;
1243 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1244 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
1245
1246 uint32_t pos = 0;
1247 napi_get_value_uint32(env, argv[ARGV_INDEX_0], &pos);
1248
1249 NAPI_MessageParcel *napiParcel = nullptr;
1250 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1251 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1252
1253 bool result = napiParcel->nativeParcel_->RewindWrite(static_cast<size_t>(pos));
1254 napi_value napiValue = nullptr;
1255 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1256 return napiValue;
1257 }
1258
JS_writeNoException(napi_env env,napi_callback_info info)1259 napi_value NAPI_MessageParcel::JS_writeNoException(napi_env env, napi_callback_info info)
1260 {
1261 napi_value thisVar = nullptr;
1262 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1263 NAPI_MessageParcel *napiParcel = nullptr;
1264 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1265 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1266 napiParcel->nativeParcel_->WriteInt32(0);
1267 napi_value result = nullptr;
1268 napi_get_undefined(env, &result);
1269 return result;
1270 }
1271
JS_readException(napi_env env,napi_callback_info info)1272 napi_value NAPI_MessageParcel::JS_readException(napi_env env, napi_callback_info info)
1273 {
1274 napi_value result = nullptr;
1275 napi_get_undefined(env, &result);
1276 napi_value thisVar = nullptr;
1277 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1278 NAPI_MessageParcel *napiParcel = nullptr;
1279 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1280 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1281
1282 int32_t code = napiParcel->nativeParcel_->ReadInt32();
1283 if (code == 0) {
1284 return result;
1285 }
1286 std::u16string str = napiParcel->nativeParcel_->ReadString16();
1287 napi_throw_error(env, nullptr, Str16ToStr8(str).c_str());
1288 return result;
1289 }
1290
JS_readByteArray(napi_env env,napi_callback_info info)1291 napi_value NAPI_MessageParcel::JS_readByteArray(napi_env env, napi_callback_info info)
1292 {
1293 size_t argc = 0;
1294 napi_value thisVar = nullptr;
1295 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1296
1297 NAPI_MessageParcel *napiParcel = nullptr;
1298 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1299 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1300
1301 uint32_t maxBytesLen = 40960;
1302 uint32_t arrayLength = napiParcel->nativeParcel_->ReadUint32();
1303 NAPI_ASSERT(env, arrayLength < maxBytesLen, "byte array length too large");
1304
1305 if (argc > 0) {
1306 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1307 napi_value argv[ARGV_LENGTH_1] = {0};
1308 void *data = nullptr;
1309 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1310
1311 bool isArray = false;
1312 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1313 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1314
1315 for (uint32_t i = 0; i < arrayLength; i++) {
1316 int8_t val = napiParcel->nativeParcel_->ReadInt8();
1317 napi_value num = nullptr;
1318 napi_create_int32(env, val, &num);
1319 napi_set_element(env, argv[ARGV_INDEX_0], i, num);
1320 }
1321 napi_value napiValue = nullptr;
1322 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1323 return napiValue;
1324 }
1325
1326 if (arrayLength == 0) {
1327 napi_value result = nullptr;
1328 napi_create_array(env, &result);
1329 return result;
1330 }
1331 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_8, napiParcel);
1332 napi_value result = nullptr;
1333 napi_create_array_with_length(env, (size_t)arrayLength, &result);
1334
1335 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1336 int8_t val = napiParcel->nativeParcel_->ReadInt8();
1337 napi_value num = nullptr;
1338 napi_create_int32(env, val, &num);
1339 napi_set_element(env, result, i, num);
1340 }
1341 return result;
1342 }
1343
JS_readShortArray(napi_env env,napi_callback_info info)1344 napi_value NAPI_MessageParcel::JS_readShortArray(napi_env env, napi_callback_info info)
1345 {
1346 size_t argc = 0;
1347 napi_value thisVar = nullptr;
1348 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1349
1350 NAPI_MessageParcel *napiParcel = nullptr;
1351 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1352 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1353
1354 int32_t arrayLength = napiParcel->nativeParcel_->ReadInt32();
1355 if (argc > 0) {
1356 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1357 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1358 napi_value argv[ARGV_LENGTH_1] = {0};
1359 void *data = nullptr;
1360 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1361
1362 bool isArray = false;
1363 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1364 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1365
1366 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1367 int16_t val = napiParcel->nativeParcel_->ReadInt16();
1368 napi_value num = nullptr;
1369 napi_create_int32(env, val, &num);
1370 napi_set_element(env, argv[ARGV_INDEX_0], i, num);
1371 }
1372 napi_value napiValue = nullptr;
1373 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1374 return napiValue;
1375 }
1376
1377 if (arrayLength <= 0) {
1378 napi_value result = nullptr;
1379 napi_create_array(env, &result);
1380 return result;
1381 }
1382 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1383 napi_value result = nullptr;
1384 napi_create_array_with_length(env, (size_t)arrayLength, &result);
1385
1386 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1387 int16_t val = napiParcel->nativeParcel_->ReadInt16();
1388 napi_value num = nullptr;
1389 napi_create_int32(env, val, &num);
1390 napi_set_element(env, result, i, num);
1391 }
1392 return result;
1393 }
1394
JS_readIntArray(napi_env env,napi_callback_info info)1395 napi_value NAPI_MessageParcel::JS_readIntArray(napi_env env, napi_callback_info info)
1396 {
1397 size_t argc = 0;
1398 napi_value thisVar = nullptr;
1399 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1400
1401 NAPI_MessageParcel *napiParcel = nullptr;
1402 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1403 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1404
1405 int32_t arrayLength = napiParcel->nativeParcel_->ReadInt32();
1406 if (argc > 0) {
1407 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1408 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1409 napi_value argv[ARGV_LENGTH_1] = {0};
1410 void *data = nullptr;
1411 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1412
1413 bool isArray = false;
1414 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1415 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1416
1417 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1418 int32_t val = napiParcel->nativeParcel_->ReadInt32();
1419 napi_value num = nullptr;
1420 napi_create_int32(env, val, &num);
1421 napi_set_element(env, argv[ARGV_INDEX_0], i, num);
1422 }
1423 napi_value napiValue = nullptr;
1424 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1425 return napiValue;
1426 }
1427
1428 if (arrayLength <= 0) {
1429 napi_value result = nullptr;
1430 napi_create_array(env, &result);
1431 return result;
1432 }
1433 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1434 napi_value result = nullptr;
1435 napi_create_array_with_length(env, (size_t)arrayLength, &result);
1436
1437 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1438 int32_t val = napiParcel->nativeParcel_->ReadInt32();
1439 napi_value num = nullptr;
1440 napi_create_int32(env, val, &num);
1441 napi_set_element(env, result, i, num);
1442 }
1443 return result;
1444 }
1445
JS_readLongArray(napi_env env,napi_callback_info info)1446 napi_value NAPI_MessageParcel::JS_readLongArray(napi_env env, napi_callback_info info)
1447 {
1448 size_t argc = 0;
1449 napi_value thisVar = nullptr;
1450 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1451
1452 NAPI_MessageParcel *napiParcel = nullptr;
1453 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1454 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1455
1456 int32_t arrayLength = napiParcel->nativeParcel_->ReadInt32();
1457 if (argc > 0) {
1458 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1459 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_64, napiParcel);
1460 napi_value argv[ARGV_LENGTH_1] = {0};
1461 void *data = nullptr;
1462 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1463
1464 bool isArray = false;
1465 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1466 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1467
1468 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1469 int64_t val = napiParcel->nativeParcel_->ReadInt64();
1470 napi_value num = nullptr;
1471 napi_create_int64(env, val, &num);
1472 napi_set_element(env, argv[ARGV_INDEX_0], i, num);
1473 }
1474 napi_value napiValue = nullptr;
1475 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1476 return napiValue;
1477 }
1478
1479 if (arrayLength <= 0) {
1480 napi_value result = nullptr;
1481 napi_create_array(env, &result);
1482 return result;
1483 }
1484 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_64, napiParcel);
1485 napi_value result = nullptr;
1486 napi_create_array_with_length(env, (size_t)arrayLength, &result);
1487
1488 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1489 int64_t val = napiParcel->nativeParcel_->ReadInt64();
1490 napi_value num = nullptr;
1491 napi_create_int64(env, val, &num);
1492 napi_set_element(env, result, i, num);
1493 }
1494 return result;
1495 }
1496
JS_readFloatArray(napi_env env,napi_callback_info info)1497 napi_value NAPI_MessageParcel::JS_readFloatArray(napi_env env, napi_callback_info info)
1498 {
1499 size_t argc = 0;
1500 napi_value thisVar = nullptr;
1501 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1502
1503 NAPI_MessageParcel *napiParcel = nullptr;
1504 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1505 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1506
1507 int32_t arrayLength = napiParcel->nativeParcel_->ReadInt32();
1508 if (argc > 0) {
1509 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1510 CHECK_READ_LENGTH(env, (size_t)arrayLength, sizeof(double), napiParcel);
1511 napi_value argv[ARGV_LENGTH_1] = {0};
1512 void *data = nullptr;
1513 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1514
1515 bool isArray = false;
1516 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1517 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1518
1519 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1520 double val = napiParcel->nativeParcel_->ReadDouble();
1521 napi_value num = nullptr;
1522 napi_create_double(env, val, &num);
1523 napi_set_element(env, argv[ARGV_INDEX_0], i, num);
1524 }
1525 napi_value napiValue = nullptr;
1526 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1527 return napiValue;
1528 }
1529
1530 if (arrayLength <= 0) {
1531 napi_value result = nullptr;
1532 napi_create_array(env, &result);
1533 return result;
1534 }
1535 CHECK_READ_LENGTH(env, (size_t)arrayLength, sizeof(double), napiParcel);
1536 napi_value result = nullptr;
1537 napi_create_array_with_length(env, (size_t)arrayLength, &result);
1538
1539 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1540 double val = napiParcel->nativeParcel_->ReadDouble();
1541 napi_value num = nullptr;
1542 napi_create_double(env, val, &num);
1543 napi_set_element(env, result, i, num);
1544 }
1545 return result;
1546 }
1547
JS_readDoubleArray(napi_env env,napi_callback_info info)1548 napi_value NAPI_MessageParcel::JS_readDoubleArray(napi_env env, napi_callback_info info)
1549 {
1550 size_t argc = 0;
1551 napi_value thisVar = nullptr;
1552 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1553
1554 NAPI_MessageParcel *napiParcel = nullptr;
1555 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1556 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1557
1558 int32_t arrayLength = napiParcel->nativeParcel_->ReadInt32();
1559 if (argc > 0) {
1560 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1561 CHECK_READ_LENGTH(env, (size_t)arrayLength, sizeof(double), napiParcel);
1562 napi_value argv[ARGV_LENGTH_1] = {0};
1563 void *data = nullptr;
1564 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1565
1566 bool isArray = false;
1567 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1568 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1569
1570 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1571 double val = napiParcel->nativeParcel_->ReadDouble();
1572 napi_value num = nullptr;
1573 napi_create_double(env, val, &num);
1574 napi_set_element(env, argv[ARGV_INDEX_0], i, num);
1575 }
1576 napi_value napiValue = nullptr;
1577 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1578 return napiValue;
1579 }
1580
1581 if (arrayLength <= 0) {
1582 napi_value result = nullptr;
1583 napi_create_array(env, &result);
1584 return result;
1585 }
1586 CHECK_READ_LENGTH(env, (size_t)arrayLength, sizeof(double), napiParcel);
1587 napi_value result = nullptr;
1588 napi_create_array_with_length(env, (size_t)arrayLength, &result);
1589
1590 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1591 double val = napiParcel->nativeParcel_->ReadDouble();
1592 napi_value num = nullptr;
1593 napi_create_double(env, val, &num);
1594 napi_set_element(env, result, i, num);
1595 }
1596 return result;
1597 }
1598
JS_readBooleanArray(napi_env env,napi_callback_info info)1599 napi_value NAPI_MessageParcel::JS_readBooleanArray(napi_env env, napi_callback_info info)
1600 {
1601 size_t argc = 0;
1602 napi_value thisVar = nullptr;
1603 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1604
1605 NAPI_MessageParcel *napiParcel = nullptr;
1606 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1607 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1608
1609 int32_t arrayLength = napiParcel->nativeParcel_->ReadInt32();
1610 if (argc > 0) {
1611 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1612 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1613 napi_value argv[ARGV_LENGTH_1] = {0};
1614 void *data = nullptr;
1615 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1616
1617 bool isArray = false;
1618 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1619 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1620
1621 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1622 int8_t val = napiParcel->nativeParcel_->ReadInt8();
1623 napi_value boolean = nullptr;
1624 napi_get_boolean(env, val, &boolean);
1625 napi_set_element(env, argv[ARGV_INDEX_0], i, boolean);
1626 }
1627 napi_value napiValue = nullptr;
1628 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1629 return napiValue;
1630 }
1631
1632 if (arrayLength <= 0) {
1633 napi_value result = nullptr;
1634 napi_create_array(env, &result);
1635 return result;
1636 }
1637
1638 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1639 napi_value result = nullptr;
1640 napi_create_array_with_length(env, (size_t)arrayLength, &result);
1641
1642 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1643 int8_t val = napiParcel->nativeParcel_->ReadInt8();
1644 napi_value boolean = nullptr;
1645 napi_get_boolean(env, val, &boolean);
1646 napi_set_element(env, result, i, boolean);
1647 }
1648 return result;
1649 }
1650
JS_readCharArray(napi_env env,napi_callback_info info)1651 napi_value NAPI_MessageParcel::JS_readCharArray(napi_env env, napi_callback_info info)
1652 {
1653 size_t argc = 0;
1654 napi_value thisVar = nullptr;
1655 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1656
1657 NAPI_MessageParcel *napiParcel = nullptr;
1658 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1659 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1660
1661 uint32_t arrayLength = napiParcel->nativeParcel_->ReadUint32();
1662 if (argc > 0) {
1663 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1664 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1665 napi_value argv[ARGV_LENGTH_1] = {0};
1666 void *data = nullptr;
1667 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1668
1669 bool isArray = false;
1670 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1671 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1672
1673 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1674 uint8_t val = napiParcel->nativeParcel_->ReadUint8();
1675 napi_value num = nullptr;
1676 napi_create_uint32(env, static_cast<uint32_t>(val), &num);
1677 napi_set_element(env, argv[ARGV_INDEX_0], i, num);
1678 }
1679 napi_value napiValue = nullptr;
1680 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1681 return napiValue;
1682 }
1683
1684 if (arrayLength == 0) {
1685 napi_value result = nullptr;
1686 napi_create_array(env, &result);
1687 return result;
1688 }
1689 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1690 napi_value result = nullptr;
1691 napi_create_array_with_length(env, (size_t)arrayLength, &result);
1692
1693 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1694 uint8_t val = napiParcel->nativeParcel_->ReadUint8();
1695 napi_value num = nullptr;
1696 napi_create_uint32(env, static_cast<uint32_t>(val), &num);
1697 napi_set_element(env, result, i, num);
1698 }
1699 return result;
1700 }
1701
JS_readStringArray(napi_env env,napi_callback_info info)1702 napi_value NAPI_MessageParcel::JS_readStringArray(napi_env env, napi_callback_info info)
1703 {
1704 size_t argc = 0;
1705 napi_value thisVar = nullptr;
1706 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1707
1708 NAPI_MessageParcel *napiParcel = nullptr;
1709 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1710 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1711
1712 uint32_t arrayLength = napiParcel->nativeParcel_->ReadUint32();
1713 if (argc > 0) {
1714 NAPI_ASSERT(env, argc == 1, "type mismatch for parameter 1");
1715 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1716 napi_value argv[ARGV_LENGTH_1] = {0};
1717 void *data = nullptr;
1718 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1719
1720 bool isArray = false;
1721 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1722 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1723
1724 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1725 if (napiParcel->nativeParcel_->GetReadableBytes() <= 0) {
1726 break;
1727 }
1728 std::u16string parcelString = napiParcel->nativeParcel_->ReadString16();
1729 std::string outString = Str16ToStr8(parcelString.c_str());
1730 napi_value val = nullptr;
1731 napi_create_string_utf8(env, outString.c_str(), outString.length(), &val);
1732 napi_set_element(env, argv[ARGV_INDEX_0], i, val);
1733 }
1734 napi_value napiValue = nullptr;
1735 NAPI_CALL(env, napi_get_boolean(env, true, &napiValue));
1736 return napiValue;
1737 }
1738
1739 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_32, napiParcel);
1740 napi_value result = nullptr;
1741 napi_create_array(env, &result);
1742 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1743 if (napiParcel->nativeParcel_->GetReadableBytes() <= 0) {
1744 break;
1745 }
1746 std::u16string parcelString = napiParcel->nativeParcel_->ReadString16();
1747 std::string outString = Str16ToStr8(parcelString.c_str());
1748 napi_value val = nullptr;
1749 napi_create_string_utf8(env, outString.c_str(), outString.length(), &val);
1750 napi_set_element(env, result, i, val);
1751 }
1752 return result;
1753 }
1754
JS_readSequenceableArray(napi_env env,napi_callback_info info)1755 napi_value NAPI_MessageParcel::JS_readSequenceableArray(napi_env env, napi_callback_info info)
1756 {
1757 size_t argc = 1;
1758 napi_value thisVar = nullptr;
1759 napi_value argv[ARGV_LENGTH_1] = { 0 };
1760 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1761 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1762
1763 NAPI_MessageParcel *napiParcel = nullptr;
1764 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1765 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1766
1767 int32_t arrayLength = napiParcel->nativeParcel_->ReadInt32();
1768 // checking here is not accurate, but we can defend some extreme attacking case.
1769 CHECK_READ_LENGTH(env, (size_t)arrayLength, BYTE_SIZE_8, napiParcel);
1770
1771 bool isArray = false;
1772 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1773 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1774 uint32_t length = 0;
1775 napi_get_array_length(env, argv[ARGV_INDEX_0], &length);
1776 if (static_cast<int32_t>(length) != arrayLength) {
1777 napi_value result = nullptr;
1778 napi_get_undefined(env, &result);
1779 napi_throw_error(env, nullptr, "Bad length while reading Sequenceable array");
1780 return result;
1781 }
1782
1783 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1784 int32_t len = napiParcel->nativeParcel_->ReadInt32();
1785 if (len > 0) {
1786 bool hasElement = false;
1787 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
1788 NAPI_ASSERT(env, hasElement == true, "parameter check error");
1789 napi_value element = nullptr;
1790 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
1791
1792 napi_value propKey = nullptr;
1793 const char *propKeyStr = "unmarshalling";
1794 napi_create_string_utf8(env, propKeyStr, strlen(propKeyStr), &propKey);
1795 napi_value prop = nullptr;
1796 napi_get_property(env, element, propKey, &prop);
1797
1798 napi_value funcArg[1] = { thisVar };
1799 napi_value callResult = nullptr;
1800 napi_call_function(env, element, prop, 1, funcArg, &callResult);
1801 if (callResult == nullptr) {
1802 ZLOGE(LOG_LABEL, "call unmarshalling failed, element index:%{public}d", i);
1803 break;
1804 }
1805 }
1806 }
1807 napi_value result = nullptr;
1808 napi_get_undefined(env, &result);
1809 return result;
1810 }
1811
JS_readRemoteObjectArray(napi_env env,napi_callback_info info)1812 napi_value NAPI_MessageParcel::JS_readRemoteObjectArray(napi_env env, napi_callback_info info)
1813 {
1814 napi_value result = nullptr;
1815 napi_get_undefined(env, &result);
1816
1817 size_t argc = 0;
1818 napi_value argv[ARGV_LENGTH_1] = { 0 };
1819 napi_value thisVar = nullptr;
1820 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1821
1822 NAPI_MessageParcel *napiParcel = nullptr;
1823 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1824 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1825
1826 int32_t arrayLength = napiParcel->nativeParcel_->ReadInt32();
1827 if (argc > 0) { // uses passed in array
1828 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1829 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1830 bool isArray = false;
1831 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
1832 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
1833 uint32_t length = 0;
1834 napi_get_array_length(env, argv[ARGV_INDEX_0], &length);
1835 if (static_cast<int32_t>(length) != arrayLength) {
1836 return result;
1837 }
1838 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1839 sptr<IRemoteObject> value = napiParcel->nativeParcel_->ReadRemoteObject();
1840 napi_value napiValue = NAPI_ohos_rpc_CreateJsRemoteObject(env, value);
1841 napi_set_element(env, argv[ARGV_INDEX_0], i, napiValue);
1842 }
1843 return result;
1844 }
1845
1846 if (arrayLength <= 0) {
1847 napi_get_null(env, &result);
1848 return result;
1849 }
1850 napi_create_array(env, &result);
1851 for (uint32_t i = 0; i < (uint32_t)arrayLength; i++) {
1852 sptr<IRemoteObject> value = napiParcel->nativeParcel_->ReadRemoteObject();
1853 napi_value napiValue = NAPI_ohos_rpc_CreateJsRemoteObject(env, value);
1854 napi_set_element(env, result, i, napiValue);
1855 }
1856 return result;
1857 }
1858
JS_readSequenceable(napi_env env,napi_callback_info info)1859 napi_value NAPI_MessageParcel::JS_readSequenceable(napi_env env, napi_callback_info info)
1860 {
1861 size_t argc = 1;
1862 napi_value argv[ARGV_LENGTH_1] = {0};
1863 napi_value thisVar = nullptr;
1864 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1865 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1866
1867 NAPI_MessageParcel *napiParcel = nullptr;
1868 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1869 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1870
1871 int32_t len = napiParcel->nativeParcel_->ReadInt32();
1872 if (len > 0) {
1873 napi_value propKey = nullptr;
1874 const char *propKeyStr = "unmarshalling";
1875 napi_create_string_utf8(env, propKeyStr, strlen(propKeyStr), &propKey);
1876 napi_value prop = nullptr;
1877 napi_get_property(env, argv[ARGV_INDEX_0], propKey, &prop);
1878
1879 napi_value funcArg[1] = {thisVar};
1880 napi_value callResult = nullptr;
1881 napi_call_function(env, argv[ARGV_INDEX_0], prop, 1, funcArg, &callResult);
1882 if (callResult != nullptr) {
1883 return callResult;
1884 }
1885 ZLOGI(LOG_LABEL, "call unmarshalling failed");
1886 }
1887
1888 napi_value napiValue = nullptr;
1889 NAPI_CALL(env, napi_get_boolean(env, false, &napiValue));
1890 return napiValue;
1891 }
1892
JS_create(napi_env env,napi_callback_info info)1893 napi_value NAPI_MessageParcel::JS_create(napi_env env, napi_callback_info info)
1894 {
1895 // new native parcel object
1896 napi_value global = nullptr;
1897 napi_status status = napi_get_global(env, &global);
1898 NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
1899 napi_value constructor = nullptr;
1900 status = napi_get_named_property(env, global, "IPCParcelConstructor_", &constructor);
1901 NAPI_ASSERT(env, status == napi_ok, "get message parcel constructor failed");
1902 napi_value jsMessageParcel;
1903 status = napi_new_instance(env, constructor, 0, nullptr, &jsMessageParcel);
1904 NAPI_ASSERT(env, status == napi_ok, "failed to construct js MessageParcel");
1905 return jsMessageParcel;
1906 }
1907
JS_reclaim(napi_env env,napi_callback_info info)1908 napi_value NAPI_MessageParcel::JS_reclaim(napi_env env, napi_callback_info info)
1909 {
1910 size_t argc = 0;
1911 napi_value thisVar = nullptr;
1912 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1913
1914 NAPI_MessageParcel *napiParcel = nullptr;
1915 napi_remove_wrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1916 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1917 delete napiParcel;
1918
1919 napi_value result = nullptr;
1920 napi_get_undefined(env, &result);
1921 return result;
1922 }
1923
JS_writeRemoteObject(napi_env env,napi_callback_info info)1924 napi_value NAPI_MessageParcel::JS_writeRemoteObject(napi_env env, napi_callback_info info)
1925 {
1926 size_t argc = 1;
1927 napi_value argv[ARGV_LENGTH_1] = { 0 };
1928 napi_value thisVar = nullptr;
1929 void *data = nullptr;
1930 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1931 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1932 napi_valuetype valueType = napi_null;
1933 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1934 napi_value napiValue = nullptr;
1935 if (valueType != napi_object) {
1936 napi_get_boolean(env, false, &napiValue);
1937 return napiValue;
1938 }
1939 sptr<IRemoteObject> remoteObject = NAPI_ohos_rpc_getNativeRemoteObject(env, argv[ARGV_INDEX_0]);
1940 if (remoteObject == nullptr) {
1941 napi_get_boolean(env, false, &napiValue);
1942 return napiValue;
1943 }
1944 NAPI_MessageParcel *napiParcel = nullptr;
1945 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1946 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1947 bool result = napiParcel->nativeParcel_->WriteRemoteObject(remoteObject);
1948 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1949 return napiValue;
1950 }
1951
JS_readRemoteObject(napi_env env,napi_callback_info info)1952 napi_value NAPI_MessageParcel::JS_readRemoteObject(napi_env env, napi_callback_info info)
1953 {
1954 size_t argc = 0;
1955 napi_value thisVar = nullptr;
1956 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1957
1958 NAPI_MessageParcel *napiParcel = nullptr;
1959 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1960 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
1961
1962 sptr<IRemoteObject> value = napiParcel->nativeParcel_->ReadRemoteObject();
1963 napi_value napiValue = NAPI_ohos_rpc_CreateJsRemoteObject(env, value);
1964 return napiValue;
1965 }
1966
JS_writeInterfaceToken(napi_env env,napi_callback_info info)1967 napi_value NAPI_MessageParcel::JS_writeInterfaceToken(napi_env env, napi_callback_info info)
1968 {
1969 size_t argc = 1;
1970 napi_value argv[ARGV_LENGTH_1] = { 0 };
1971 napi_value thisVar = nullptr;
1972 void *data = nullptr;
1973 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1974 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
1975
1976 napi_valuetype valueType = napi_null;
1977 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
1978 NAPI_ASSERT(env, valueType == napi_string, "type mismatch for parameter");
1979
1980 size_t bufferSize = 0;
1981 size_t maxSize = 40960;
1982 napi_get_value_string_utf8(env, argv[ARGV_INDEX_0], nullptr, 0, &bufferSize);
1983 NAPI_ASSERT(env, bufferSize < maxSize, "string length too large");
1984
1985 char stringValue[bufferSize + 1];
1986 size_t jsStringLength = 0;
1987 napi_get_value_string_utf8(env, argv[ARGV_INDEX_0], stringValue, bufferSize + 1, &jsStringLength);
1988 NAPI_ASSERT(env, jsStringLength == bufferSize, "string length wrong");
1989
1990 NAPI_MessageParcel *napiParcel = nullptr;
1991 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
1992 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
1993
1994 std::string parcelString = stringValue;
1995 bool result = napiParcel->nativeParcel_->WriteInterfaceToken(to_utf16(parcelString));
1996
1997 napi_value napiValue = nullptr;
1998 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
1999 return napiValue;
2000 }
2001
JS_readInterfaceToken(napi_env env,napi_callback_info info)2002 napi_value NAPI_MessageParcel::JS_readInterfaceToken(napi_env env, napi_callback_info info)
2003 {
2004 size_t argc = 0;
2005 napi_value thisVar = nullptr;
2006 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
2007
2008 NAPI_MessageParcel *napiParcel = nullptr;
2009 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2010 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
2011
2012 std::u16string parcelString = napiParcel->nativeParcel_->ReadInterfaceToken();
2013 std::string outString = Str16ToStr8(parcelString.c_str());
2014 napi_value napiValue = nullptr;
2015 napi_create_string_utf8(env, outString.c_str(), outString.length(), &napiValue);
2016 return napiValue;
2017 }
2018
JS_CloseFileDescriptor(napi_env env,napi_callback_info info)2019 napi_value NAPI_MessageParcel::JS_CloseFileDescriptor(napi_env env, napi_callback_info info)
2020 {
2021 size_t argc = 1;
2022 napi_value argv[ARGV_LENGTH_1] = { 0 };
2023 napi_value thisVar = nullptr;
2024 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2025 NAPI_ASSERT(env, argc == 1, "requires 1 parameters");
2026 napi_valuetype valueType = napi_null;
2027 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
2028 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
2029 int32_t fd = -1;
2030 napi_get_value_int32(env, argv[ARGV_INDEX_0], &fd);
2031 close(fd);
2032 napi_value result = nullptr;
2033 napi_get_undefined(env, &result);
2034 return result;
2035 }
2036
JS_DupFileDescriptor(napi_env env,napi_callback_info info)2037 napi_value NAPI_MessageParcel::JS_DupFileDescriptor(napi_env env, napi_callback_info info)
2038 {
2039 size_t argc = 1;
2040 napi_value argv[ARGV_LENGTH_1] = { 0 };
2041 napi_value thisVar = nullptr;
2042 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2043 NAPI_ASSERT(env, argc == 1, "requires 1 parameters");
2044 napi_valuetype valueType = napi_null;
2045 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
2046 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
2047 int32_t fd = -1;
2048 napi_get_value_int32(env, argv[ARGV_INDEX_0], &fd);
2049 int32_t dupResult = dup(fd);
2050 napi_value napiValue;
2051 napi_create_int32(env, dupResult, &napiValue);
2052 return napiValue;
2053 }
2054
JS_ContainFileDescriptors(napi_env env,napi_callback_info info)2055 napi_value NAPI_MessageParcel::JS_ContainFileDescriptors(napi_env env, napi_callback_info info)
2056 {
2057 size_t argc = 0;
2058 napi_value thisVar = nullptr;
2059 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
2060 NAPI_MessageParcel *napiParcel = nullptr;
2061 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2062 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
2063 bool result = napiParcel->nativeParcel_->ContainFileDescriptors();
2064 napi_value napiValue = nullptr;
2065 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
2066 return napiValue;
2067 }
2068
JS_WriteFileDescriptor(napi_env env,napi_callback_info info)2069 napi_value NAPI_MessageParcel::JS_WriteFileDescriptor(napi_env env, napi_callback_info info)
2070 {
2071 size_t argc = 1;
2072 napi_value argv[ARGV_LENGTH_1] = { 0 };
2073 napi_value thisVar = nullptr;
2074 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2075 NAPI_ASSERT(env, argc == 1, "requires 1 parameters");
2076 napi_valuetype valueType = napi_null;
2077 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
2078 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
2079 int32_t fd = -1;
2080 napi_get_value_int32(env, argv[ARGV_INDEX_0], &fd);
2081 NAPI_MessageParcel *napiParcel = nullptr;
2082 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2083 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
2084 bool result = napiParcel->nativeParcel_->WriteFileDescriptor(fd);
2085 napi_value napiValue = nullptr;
2086 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
2087 return napiValue;
2088 }
2089
JS_ReadFileDescriptor(napi_env env,napi_callback_info info)2090 napi_value NAPI_MessageParcel::JS_ReadFileDescriptor(napi_env env, napi_callback_info info)
2091 {
2092 size_t argc = 0;
2093 napi_value thisVar = nullptr;
2094 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
2095 NAPI_MessageParcel *napiParcel = nullptr;
2096 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2097 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
2098 int32_t result = napiParcel->nativeParcel_->ReadFileDescriptor();
2099 napi_value napiValue;
2100 napi_create_int32(env, result, &napiValue);
2101 return napiValue;
2102 }
2103
JS_WriteAshmem(napi_env env,napi_callback_info info)2104 napi_value NAPI_MessageParcel::JS_WriteAshmem(napi_env env, napi_callback_info info)
2105 {
2106 size_t argc = 1;
2107 napi_value argv[ARGV_LENGTH_1] = { 0 };
2108 napi_value thisVar = nullptr;
2109 void *data = nullptr;
2110 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
2111 NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
2112 // check type is Ashmem
2113 napi_value global = nullptr;
2114 napi_status status = napi_get_global(env, &global);
2115 NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
2116 napi_value constructor = nullptr;
2117 status = napi_get_named_property(env, global, "AshmemConstructor_", &constructor);
2118 NAPI_ASSERT(env, status == napi_ok, "get Ashmem constructor failed");
2119 bool isAshmem = false;
2120 napi_instanceof(env, argv[ARGV_INDEX_0], constructor, &isAshmem);
2121 NAPI_ASSERT(env, isAshmem == true, "parameter is not instanceof Ashmem");
2122 NAPIAshmem *napiAshmem = nullptr;
2123 napi_unwrap(env, argv[ARGV_INDEX_0], reinterpret_cast<void **>(&napiAshmem));
2124 NAPI_ASSERT(env, napiAshmem != nullptr, "napiAshmem is null");
2125 sptr<Ashmem> nativeAshmem = napiAshmem->GetAshmem();
2126 NAPI_MessageParcel *napiParcel = nullptr;
2127 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2128 NAPI_ASSERT(env, napiParcel != nullptr, "napiParcel is null");
2129 bool result = napiParcel->nativeParcel_->WriteAshmem(nativeAshmem);
2130 napi_value napiValue = nullptr;
2131 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
2132 return napiValue;
2133 }
2134
JS_ReadAshmem(napi_env env,napi_callback_info info)2135 napi_value NAPI_MessageParcel::JS_ReadAshmem(napi_env env, napi_callback_info info)
2136 {
2137 size_t argc = 0;
2138 napi_value thisVar = nullptr;
2139 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
2140
2141 NAPI_MessageParcel *napiParcel = nullptr;
2142 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2143 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
2144 sptr<Ashmem> nativeAshmem = napiParcel->nativeParcel_->ReadAshmem();
2145 napi_value global = nullptr;
2146 napi_status status = napi_get_global(env, &global);
2147 NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
2148 napi_value constructor = nullptr;
2149 status = napi_get_named_property(env, global, "AshmemConstructor_", &constructor);
2150 NAPI_ASSERT(env, status == napi_ok, "get Ashmem constructor failed");
2151 napi_value jsAshmem;
2152 status = napi_new_instance(env, constructor, 0, nullptr, &jsAshmem);
2153 NAPI_ASSERT(env, status == napi_ok, "failed to construct js Ashmem");
2154 NAPIAshmem *napiAshmem = nullptr;
2155 napi_unwrap(env, jsAshmem, reinterpret_cast<void **>(&napiAshmem));
2156 NAPI_ASSERT(env, napiAshmem != nullptr, "napiAshmem is null");
2157 napiAshmem->SetAshmem(nativeAshmem);
2158 return jsAshmem;
2159 }
2160
JS_WriteRawData(napi_env env,napi_callback_info info)2161 napi_value NAPI_MessageParcel::JS_WriteRawData(napi_env env, napi_callback_info info)
2162 {
2163 size_t argc = 2;
2164 napi_value argv[ARGV_LENGTH_2] = {0};
2165 napi_value thisVar = nullptr;
2166 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2167 NAPI_ASSERT(env, argc == 2, "requires 2 parameter");
2168 bool isArray = false;
2169 napi_is_array(env, argv[ARGV_INDEX_0], &isArray);
2170 NAPI_ASSERT(env, isArray == true, "type mismatch for parameter 1");
2171
2172 std::vector<int32_t> array;
2173 uint32_t arrayLength = 0;
2174 napi_get_array_length(env, argv[ARGV_INDEX_0], &arrayLength);
2175
2176 for (size_t i = 0; i < arrayLength; i++) {
2177 bool hasElement = false;
2178 napi_has_element(env, argv[ARGV_INDEX_0], i, &hasElement);
2179 NAPI_ASSERT(env, hasElement == true, "parameter check error");
2180
2181 napi_value element = nullptr;
2182 napi_get_element(env, argv[ARGV_INDEX_0], i, &element);
2183
2184 int32_t value = 0;
2185 napi_get_value_int32(env, element, &value);
2186 array.push_back(value);
2187 }
2188
2189 napi_valuetype valueType = napi_null;
2190 napi_typeof(env, argv[ARGV_INDEX_1], &valueType);
2191 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 2");
2192 int32_t size = 0;
2193 napi_get_value_int32(env, argv[ARGV_INDEX_1], &size);
2194 NAPI_MessageParcel *napiParcel = nullptr;
2195 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2196 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
2197 bool result = napiParcel->nativeParcel_->WriteRawData(array.data(), size * BYTE_SIZE_32);
2198 napi_value napiValue = nullptr;
2199 NAPI_CALL(env, napi_get_boolean(env, result, &napiValue));
2200 return napiValue;
2201 }
2202
JS_ReadRawData(napi_env env,napi_callback_info info)2203 napi_value NAPI_MessageParcel::JS_ReadRawData(napi_env env, napi_callback_info info)
2204 {
2205 size_t argc = 1;
2206 napi_value argv[ARGV_LENGTH_1] = { 0 };
2207 napi_value thisVar = nullptr;
2208 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2209 NAPI_ASSERT(env, argc == 1, "requires 1 parameters");
2210 napi_valuetype valueType = napi_null;
2211 napi_typeof(env, argv[ARGV_INDEX_0], &valueType);
2212 NAPI_ASSERT(env, valueType == napi_number, "type mismatch for parameter 1");
2213 int32_t arraySize = 0;
2214 napi_get_value_int32(env, argv[ARGV_INDEX_0], &arraySize);
2215 NAPI_MessageParcel *napiParcel = nullptr;
2216 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2217 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
2218 const void *rawData = napiParcel->nativeParcel_->ReadRawData(arraySize * BYTE_SIZE_32);
2219 NAPI_ASSERT_BASE(env, rawData != nullptr, "rawData is null", nullptr);
2220 // [c++] rawData -> byteBuffer()[js]
2221 napi_value result = nullptr;
2222 if (arraySize <= 0) {
2223 napi_create_array(env, &result);
2224 return result;
2225 }
2226 napi_create_array_with_length(env, (size_t)arraySize, &result);
2227 const int32_t *ptr = static_cast<const int32_t *>(rawData);
2228 for (uint32_t i = 0; i < (uint32_t)arraySize; i++) {
2229 napi_value num = nullptr;
2230 napi_create_int32(env, ptr[i], &num);
2231 napi_set_element(env, result, i, num);
2232 }
2233 return result;
2234 }
2235
JS_GetRawDataCapacity(napi_env env,napi_callback_info info)2236 napi_value NAPI_MessageParcel::JS_GetRawDataCapacity(napi_env env, napi_callback_info info)
2237 {
2238 size_t argc = 0;
2239 napi_value thisVar = nullptr;
2240 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
2241 NAPI_MessageParcel *napiParcel = nullptr;
2242 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiParcel));
2243 NAPI_ASSERT_BASE(env, napiParcel != nullptr, "napiParcel is null", nullptr);
2244 uint32_t result = napiParcel->nativeParcel_->GetRawDataCapacity();
2245 napi_value napiValue;
2246 napi_create_uint32(env, result, &napiValue);
2247 return napiValue;
2248 }
2249
Export(napi_env env,napi_value exports)2250 napi_value NAPI_MessageParcel::Export(napi_env env, napi_value exports)
2251 {
2252 const std::string className = "MessageParcel";
2253 napi_property_descriptor properties[] = {
2254 DECLARE_NAPI_STATIC_FUNCTION("create", NAPI_MessageParcel::JS_create),
2255 DECLARE_NAPI_FUNCTION("reclaim", NAPI_MessageParcel::JS_reclaim),
2256 DECLARE_NAPI_FUNCTION("writeRemoteObject", NAPI_MessageParcel::JS_writeRemoteObject),
2257 DECLARE_NAPI_FUNCTION("readRemoteObject", NAPI_MessageParcel::JS_readRemoteObject),
2258 DECLARE_NAPI_FUNCTION("writeInterfaceToken", NAPI_MessageParcel::JS_writeInterfaceToken),
2259 DECLARE_NAPI_FUNCTION("readInterfaceToken", NAPI_MessageParcel::JS_readInterfaceToken),
2260 DECLARE_NAPI_FUNCTION("getSize", NAPI_MessageParcel::JS_getSize),
2261 DECLARE_NAPI_FUNCTION("getCapacity", NAPI_MessageParcel::JS_getCapacity),
2262 DECLARE_NAPI_FUNCTION("setSize", NAPI_MessageParcel::JS_setSize),
2263 DECLARE_NAPI_FUNCTION("setCapacity", NAPI_MessageParcel::JS_setCapacity),
2264 DECLARE_NAPI_FUNCTION("getWritableBytes", NAPI_MessageParcel::JS_getWritableBytes),
2265 DECLARE_NAPI_FUNCTION("getReadableBytes", NAPI_MessageParcel::JS_getReadableBytes),
2266 DECLARE_NAPI_FUNCTION("getReadPosition", NAPI_MessageParcel::JS_getReadPosition),
2267 DECLARE_NAPI_FUNCTION("getWritePosition", NAPI_MessageParcel::JS_getWritePosition),
2268 DECLARE_NAPI_FUNCTION("rewindRead", NAPI_MessageParcel::JS_rewindRead),
2269 DECLARE_NAPI_FUNCTION("rewindWrite", NAPI_MessageParcel::JS_rewindWrite),
2270 DECLARE_NAPI_FUNCTION("writeNoException", NAPI_MessageParcel::JS_writeNoException),
2271 DECLARE_NAPI_FUNCTION("readException", NAPI_MessageParcel::JS_readException),
2272 DECLARE_NAPI_FUNCTION("writeByte", NAPI_MessageParcel::JS_writeByte),
2273 DECLARE_NAPI_FUNCTION("writeShort", NAPI_MessageParcel::JS_writeShort),
2274 DECLARE_NAPI_FUNCTION("writeInt", NAPI_MessageParcel::JS_writeInt),
2275 DECLARE_NAPI_FUNCTION("writeLong", NAPI_MessageParcel::JS_writeLong),
2276 DECLARE_NAPI_FUNCTION("writeFloat", NAPI_MessageParcel::JS_writeFloat),
2277 DECLARE_NAPI_FUNCTION("writeDouble", NAPI_MessageParcel::JS_writeDouble),
2278 DECLARE_NAPI_FUNCTION("writeBoolean", NAPI_MessageParcel::JS_writeBoolean),
2279 DECLARE_NAPI_FUNCTION("writeChar", NAPI_MessageParcel::JS_writeChar),
2280 DECLARE_NAPI_FUNCTION("writeString", NAPI_MessageParcel::JS_writeString),
2281 DECLARE_NAPI_FUNCTION("writeSequenceable", NAPI_MessageParcel::JS_writeSequenceable),
2282 DECLARE_NAPI_FUNCTION("writeByteArray", NAPI_MessageParcel::JS_writeByteArray),
2283 DECLARE_NAPI_FUNCTION("writeShortArray", NAPI_MessageParcel::JS_writeShortArray),
2284 DECLARE_NAPI_FUNCTION("writeIntArray", NAPI_MessageParcel::JS_writeIntArray),
2285 DECLARE_NAPI_FUNCTION("writeLongArray", NAPI_MessageParcel::JS_writeLongArray),
2286 DECLARE_NAPI_FUNCTION("writeFloatArray", NAPI_MessageParcel::JS_writeFloatArray),
2287 DECLARE_NAPI_FUNCTION("writeDoubleArray", NAPI_MessageParcel::JS_writeDoubleArray),
2288 DECLARE_NAPI_FUNCTION("writeBooleanArray", NAPI_MessageParcel::JS_writeBooleanArray),
2289 DECLARE_NAPI_FUNCTION("writeCharArray", NAPI_MessageParcel::JS_writeCharArray),
2290 DECLARE_NAPI_FUNCTION("writeStringArray", NAPI_MessageParcel::JS_writeStringArray),
2291 DECLARE_NAPI_FUNCTION("writeSequenceableArray", NAPI_MessageParcel::JS_writeSequenceableArray),
2292 DECLARE_NAPI_FUNCTION("writeRemoteObjectArray", NAPI_MessageParcel::JS_writeRemoteObjectArray),
2293 DECLARE_NAPI_FUNCTION("readByte", NAPI_MessageParcel::JS_readByte),
2294 DECLARE_NAPI_FUNCTION("readShort", NAPI_MessageParcel::JS_readShort),
2295 DECLARE_NAPI_FUNCTION("readInt", NAPI_MessageParcel::JS_readInt),
2296 DECLARE_NAPI_FUNCTION("readLong", NAPI_MessageParcel::JS_readLong),
2297 DECLARE_NAPI_FUNCTION("readFloat", NAPI_MessageParcel::JS_readFloat),
2298 DECLARE_NAPI_FUNCTION("readDouble", NAPI_MessageParcel::JS_readDouble),
2299 DECLARE_NAPI_FUNCTION("readBoolean", NAPI_MessageParcel::JS_readBoolean),
2300 DECLARE_NAPI_FUNCTION("readChar", NAPI_MessageParcel::JS_readChar),
2301 DECLARE_NAPI_FUNCTION("readString", NAPI_MessageParcel::JS_readString),
2302 DECLARE_NAPI_FUNCTION("readSequenceable", NAPI_MessageParcel::JS_readSequenceable),
2303 DECLARE_NAPI_FUNCTION("readByteArray", NAPI_MessageParcel::JS_readByteArray),
2304 DECLARE_NAPI_FUNCTION("readShortArray", NAPI_MessageParcel::JS_readShortArray),
2305 DECLARE_NAPI_FUNCTION("readIntArray", NAPI_MessageParcel::JS_readIntArray),
2306 DECLARE_NAPI_FUNCTION("readLongArray", NAPI_MessageParcel::JS_readLongArray),
2307 DECLARE_NAPI_FUNCTION("readFloatArray", NAPI_MessageParcel::JS_readFloatArray),
2308 DECLARE_NAPI_FUNCTION("readDoubleArray", NAPI_MessageParcel::JS_readDoubleArray),
2309 DECLARE_NAPI_FUNCTION("readBooleanArray", NAPI_MessageParcel::JS_readBooleanArray),
2310 DECLARE_NAPI_FUNCTION("readCharArray", NAPI_MessageParcel::JS_readCharArray),
2311 DECLARE_NAPI_FUNCTION("readStringArray", NAPI_MessageParcel::JS_readStringArray),
2312 DECLARE_NAPI_FUNCTION("readSequenceableArray", NAPI_MessageParcel::JS_readSequenceableArray),
2313 DECLARE_NAPI_FUNCTION("readRemoteObjectArray", NAPI_MessageParcel::JS_readRemoteObjectArray),
2314 DECLARE_NAPI_STATIC_FUNCTION("closeFileDescriptor", NAPI_MessageParcel::JS_CloseFileDescriptor),
2315 DECLARE_NAPI_STATIC_FUNCTION("dupFileDescriptor", NAPI_MessageParcel::JS_DupFileDescriptor),
2316 DECLARE_NAPI_FUNCTION("writeFileDescriptor", NAPI_MessageParcel::JS_WriteFileDescriptor),
2317 DECLARE_NAPI_FUNCTION("readFileDescriptor", NAPI_MessageParcel::JS_ReadFileDescriptor),
2318 DECLARE_NAPI_FUNCTION("containFileDescriptors", NAPI_MessageParcel::JS_ContainFileDescriptors),
2319 DECLARE_NAPI_FUNCTION("writeAshmem", NAPI_MessageParcel::JS_WriteAshmem),
2320 DECLARE_NAPI_FUNCTION("readAshmem", NAPI_MessageParcel::JS_ReadAshmem),
2321 DECLARE_NAPI_FUNCTION("getRawDataCapacity", NAPI_MessageParcel::JS_GetRawDataCapacity),
2322 DECLARE_NAPI_FUNCTION("writeRawData", NAPI_MessageParcel::JS_WriteRawData),
2323 DECLARE_NAPI_FUNCTION("readRawData", NAPI_MessageParcel::JS_ReadRawData),
2324 };
2325 napi_value constructor = nullptr;
2326 napi_define_class(env, className.c_str(), className.length(), JS_constructor, nullptr,
2327 sizeof(properties) / sizeof(properties[0]), properties, &constructor);
2328 NAPI_ASSERT(env, constructor != nullptr, "define js class MessageParcel failed");
2329 napi_status status = napi_set_named_property(env, exports, "MessageParcel", constructor);
2330 NAPI_ASSERT(env, status == napi_ok, "set property MessageParcel failed");
2331 napi_value global = nullptr;
2332 status = napi_get_global(env, &global);
2333 NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
2334 status = napi_set_named_property(env, global, "IPCParcelConstructor_", constructor);
2335 NAPI_ASSERT(env, status == napi_ok, "set message parcel constructor failed");
2336 return exports;
2337 }
2338
JS_constructor(napi_env env,napi_callback_info info)2339 napi_value NAPI_MessageParcel::JS_constructor(napi_env env, napi_callback_info info)
2340 {
2341 napi_value thisVar = nullptr;
2342 size_t argc = 1;
2343 napi_value argv[ARGV_LENGTH_1] = { 0 };
2344 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2345 NAPI_ASSERT(env, status == napi_ok, "napi get callback info failed");
2346 MessageParcel *parcel = nullptr;
2347 if (argc > 0) {
2348 napi_unwrap(env, argv[ARGV_INDEX_0], reinterpret_cast<void **>(&parcel));
2349 NAPI_ASSERT(env, parcel != nullptr, "parcel is null");
2350 }
2351 // new native parcel object
2352 auto messageParcel = new NAPI_MessageParcel(env, thisVar, parcel);
2353 // connect native object to js thisVar
2354 status = napi_wrap(
2355 env, thisVar, messageParcel,
2356 [](napi_env env, void *data, void *hint) {
2357 NAPI_MessageParcel *messageParcel = reinterpret_cast<NAPI_MessageParcel *>(data);
2358 if (!messageParcel->owner) {
2359 delete messageParcel;
2360 }
2361 },
2362 nullptr, nullptr);
2363 NAPI_ASSERT(env, status == napi_ok, "napi wrap message parcel failed");
2364 return thisVar;
2365 }
2366 } // namespace OHOS
2367