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