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