1 /*
2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "jsi.h"
16
17 #include <cstdarg>
18 #include <cstring>
19 #if (OHOS_ACELITE_PRODUCT_WATCH == 1)
20 #include "securec.h"
21 #endif // OHOS_ACELITE_PRODUCT_WATCH
22 #include "ace_log.h"
23 #include "ace_mem_base.h"
24 #include "internal/jsi_internal.h"
25
26 namespace OHOS {
27 namespace ACELite {
GetGlobalObject()28 JSIValue JSI::GetGlobalObject()
29 {
30 #if (ENABLE_JERRY == 1)
31 return AS_JSI_VALUE(jerry_get_global_object());
32 #else
33 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetGlobalObject has not been implemented in this js engine!");
34 return CreateUndefined();
35 #endif
36 }
37
CreateObject()38 JSIValue JSI::CreateObject()
39 {
40 #if (ENABLE_JERRY == 1)
41 return AS_JSI_VALUE(jerry_create_object());
42 #else
43 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateObject has not been implemented in this js engine!");
44 return CreateUndefined();
45 #endif
46 }
47
SetProperty(JSIValue object,JSIValue key,JSIValue value)48 void JSI::SetProperty(JSIValue object, JSIValue key, JSIValue value)
49 {
50 if (!ValueIsObject(object)) {
51 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetProperty failed!");
52 return;
53 }
54 #if (ENABLE_JERRY == 1)
55 jerry_value_t jObject = AS_JERRY_VALUE(object);
56 jerry_value_t jKey = AS_JERRY_VALUE(key);
57 jerry_value_t jVal = AS_JERRY_VALUE(value);
58
59 jerry_release_value(jerry_set_property(jObject, jKey, jVal));
60 #else
61 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetProperty has not been implemented in this js engine!");
62 #endif
63 }
64
SetNamedProperty(JSIValue object,const char * const propName,JSIValue value)65 void JSI::SetNamedProperty(JSIValue object, const char * const propName, JSIValue value)
66 {
67 if (!ValueIsObject(object) || (propName == nullptr)) {
68 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetNamedProperty failed!");
69 return;
70 }
71 #if (ENABLE_JERRY == 1)
72 jerry_value_t jKey = jerry_create_string(reinterpret_cast<const jerry_char_t *>(propName));
73 SetProperty(object, AS_JSI_VALUE(jKey), value);
74 jerry_release_value(jKey);
75 #else
76 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetNamedProperty has not been implemented in this js engine!");
77 #endif
78 }
79
SetNumberProperty(JSIValue object,const char * const propName,double value)80 void JSI::SetNumberProperty(JSIValue object, const char * const propName, double value)
81 {
82 if (!ValueIsObject(object)) {
83 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetNumberProperty failed!");
84 return;
85 }
86 JSIValue numValue = CreateNumber(value);
87 SetNamedProperty(object, propName, numValue);
88 ReleaseValue(numValue);
89 }
90
SetBooleanProperty(JSIValue object,const char * const propName,bool value)91 void JSI::SetBooleanProperty(JSIValue object, const char * const propName, bool value)
92 {
93 if (!ValueIsObject(object)) {
94 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetBooleanProperty failed!");
95 return;
96 }
97 JSIValue boolValue = CreateBoolean(value);
98 SetNamedProperty(object, propName, boolValue);
99 ReleaseValue(boolValue);
100 }
101
SetStringProperty(JSIValue object,const char * const propName,const char * value)102 void JSI::SetStringProperty(JSIValue object, const char * const propName, const char *value)
103 {
104 if (!ValueIsObject(object)) {
105 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetStringProperty failed!");
106 return;
107 }
108 JSIValue strValue = CreateString(value);
109 SetNamedProperty(object, propName, strValue);
110 ReleaseValue(strValue);
111 }
112
SetStringPropertyWithBufferSize(JSIValue object,const char * const propName,const char * value,size_t size)113 void JSI::SetStringPropertyWithBufferSize(JSIValue object, const char * const propName, const char *value, size_t size)
114 {
115 if (!ValueIsObject(object)) {
116 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetStringPropertyWithBufferSize failed!");
117 return;
118 }
119 JSIValue strValue = CreateStringWithBufferSize(value, size);
120 SetNamedProperty(object, propName, strValue);
121 ReleaseValue(strValue);
122 }
123
124 #if (ENABLE_JERRY == 1)
125 /**
126 * @brief: CreateJerryFuncHelper is used to create jerry function
127 * along with JSI::CreateFunction, for internal use only.
128 */
CreateJerryFuncHelper(const jerry_value_t func,const jerry_value_t thisVal,const jerry_value_t * args,const jerry_length_t argsNum)129 static jerry_value_t CreateJerryFuncHelper(const jerry_value_t func,
130 const jerry_value_t thisVal,
131 const jerry_value_t *args,
132 const jerry_length_t argsNum)
133 {
134 void *nativePointer = nullptr;
135 bool exist = jerry_get_object_native_pointer(func, &nativePointer, nullptr);
136 if (!exist || (nativePointer == nullptr) || (argsNum >= UINT8_MAX)) {
137 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateJerryFuncHelper get function pointer failed!");
138 return jerry_create_undefined();
139 }
140
141 JSIFunctionHandler handler = reinterpret_cast<JSIFunctionHandler>(nativePointer);
142 JSIValue jsiThis = AS_JSI_VALUE(thisVal);
143 uint8_t jsiArgsNum = (uint8_t)argsNum;
144 if ((args == nullptr) || (jsiArgsNum == 0)) {
145 return AS_JERRY_VALUE(handler(jsiThis, nullptr, 0));
146 }
147 JSIValue *jsiArgs = static_cast<JSIValue *>(ace_malloc(sizeof(JSIValue) * jsiArgsNum));
148 if (jsiArgs == nullptr) {
149 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateJerryFuncHelper allocate memory failed!");
150 return jerry_create_undefined();
151 }
152
153 for (uint8_t index = 0; index < jsiArgsNum; index++) {
154 jsiArgs[index] = AS_JSI_VALUE(args[index]);
155 }
156 JSIValue res = handler(jsiThis, jsiArgs, jsiArgsNum);
157 ace_free(jsiArgs);
158 jsiArgs = nullptr;
159 return AS_JERRY_VALUE(res);
160 }
161 #endif
162
CreateFunction(JSIFunctionHandler handler)163 JSIValue JSI::CreateFunction(JSIFunctionHandler handler)
164 {
165 if (handler == nullptr) {
166 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateFunction failed!");
167 return CreateUndefined();
168 }
169 #if (ENABLE_JERRY == 1)
170 jerry_value_t jFunc = jerry_create_external_function(CreateJerryFuncHelper);
171 void *nativePointer = reinterpret_cast<void *>(handler);
172 jerry_set_object_native_pointer(jFunc, nativePointer, nullptr);
173 return AS_JSI_VALUE(jFunc);
174 #else
175 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateFunction has not been implemented in this js engine!");
176 return CreateUndefined();
177 #endif
178 }
179
CreateString(const char * const str)180 JSIValue JSI::CreateString(const char * const str)
181 {
182 if (str == nullptr) {
183 return CreateUndefined();
184 }
185 #if (ENABLE_JERRY == 1)
186 return AS_JSI_VALUE(jerry_create_string(reinterpret_cast<const jerry_char_t *>(str)));
187 #else
188 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateString has not been implemented in this js engine!");
189 return CreateUndefined();
190 #endif
191 }
192
CreateStringWithBufferSize(const char * const str,size_t size)193 JSIValue JSI::CreateStringWithBufferSize(const char * const str, size_t size)
194 {
195 if (str == nullptr) {
196 return CreateUndefined();
197 }
198 #if (ENABLE_JERRY == 1)
199 return AS_JSI_VALUE(jerry_create_string_sz(reinterpret_cast<const jerry_char_t *>(str), size));
200 #else
201 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateStringWithBufferSize has not been implemented in this js engine!");
202 return CreateUndefined();
203 #endif
204 }
205
CreateUndefined()206 JSIValue JSI::CreateUndefined()
207 {
208 #if (ENABLE_JERRY == 1)
209 return AS_JSI_VALUE(jerry_create_undefined());
210 #else
211 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateUndefined has not been implemented in this js engine!");
212 return nullptr;
213 #endif
214 }
215
ValueIsFunction(JSIValue value)216 bool JSI::ValueIsFunction(JSIValue value)
217 {
218 #if (ENABLE_JERRY == 1)
219 return jerry_value_is_function(AS_JERRY_VALUE(value));
220 #else
221 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsFunction has not been implemented in this js engine!");
222 return false;
223 #endif
224 }
225
ValueIsUndefined(JSIValue value)226 bool JSI::ValueIsUndefined(JSIValue value)
227 {
228 #if (ENABLE_JERRY == 1)
229 return jerry_value_is_undefined(AS_JERRY_VALUE(value));
230 #else
231 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsUndefined has not been implemented in this js engine!");
232 return false;
233 #endif
234 }
235
ValueIsNumber(JSIValue value)236 bool JSI::ValueIsNumber(JSIValue value)
237 {
238 #if (ENABLE_JERRY == 1)
239 return jerry_value_is_number(AS_JERRY_VALUE(value));
240 #else
241 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsNumber has not been implemented in this js engine!");
242 return false;
243 #endif
244 }
245
ValueIsString(JSIValue value)246 bool JSI::ValueIsString(JSIValue value)
247 {
248 #if (ENABLE_JERRY == 1)
249 return jerry_value_is_string(AS_JERRY_VALUE(value));
250 #else
251 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsString has not been implemented in this js engine!");
252 return false;
253 #endif
254 }
255
ValueIsBoolean(JSIValue value)256 bool JSI::ValueIsBoolean(JSIValue value)
257 {
258 #if (ENABLE_JERRY == 1)
259 return jerry_value_is_boolean(AS_JERRY_VALUE(value));
260 #else
261 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsBoolean has not been implemented in this js engine!");
262 return false;
263 #endif
264 }
265
ValueIsNull(JSIValue value)266 bool JSI::ValueIsNull(JSIValue value)
267 {
268 #if (ENABLE_JERRY == 1)
269 return jerry_value_is_null(AS_JERRY_VALUE(value));
270 #else
271 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsNull has not been implemented in this js engine!");
272 return false;
273 #endif
274 }
275
ValueIsObject(JSIValue value)276 bool JSI::ValueIsObject(JSIValue value)
277 {
278 #if (ENABLE_JERRY == 1)
279 return jerry_value_is_object(AS_JERRY_VALUE(value));
280 #else
281 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsObject has not been implemented in this js engine!");
282 return false;
283 #endif
284 }
285
ValueIsError(JSIValue value)286 bool JSI::ValueIsError(JSIValue value)
287 {
288 #if (ENABLE_JERRY == 1)
289 return jerry_value_is_error(AS_JERRY_VALUE(value));
290 #else
291 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsError has not been implemented in this js engine!");
292 return false;
293 #endif
294 }
295
JsonStringify(JSIValue value)296 char *JSI::JsonStringify(JSIValue value)
297 {
298 if (!ValueIsObject(value)) {
299 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:JsonStringify failed!");
300 return nullptr;
301 }
302 #if (ENABLE_JERRY == 1)
303 jerry_value_t stringified = jerry_json_stringify(AS_JERRY_VALUE(value));
304 char *res = ValueToString(AS_JSI_VALUE(stringified));
305 jerry_release_value(stringified);
306 return res;
307 #else
308 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:JsonStringify has not been implemented in this js engine!");
309 return nullptr;
310 #endif
311 }
312
JsonParse(const char * const str)313 JSIValue JSI::JsonParse(const char * const str)
314 {
315 if (str == nullptr) {
316 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:JsonParse failed!");
317 return CreateUndefined();
318 }
319 #if (ENABLE_JERRY == 1)
320 jerry_value_t jVal = jerry_json_parse(reinterpret_cast<const jerry_char_t *>(str), strlen(str));
321 return AS_JSI_VALUE(jVal);
322 #else
323 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:JsonParse has not been implemented in this js engine!");
324 return CreateUndefined();
325 #endif
326 }
327
GetProperty(JSIValue object,JSIValue key)328 JSIValue JSI::GetProperty(JSIValue object, JSIValue key)
329 {
330 if (!ValueIsObject(object)) {
331 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetProperty failed!");
332 return CreateUndefined();
333 }
334 #if (ENABLE_JERRY == 1)
335 jerry_value_t jObject = AS_JERRY_VALUE(object);
336 jerry_value_t jKey = AS_JERRY_VALUE(key);
337 return AS_JSI_VALUE(jerry_get_property(jObject, jKey));
338 #else
339 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetProperty has not been implemented in this js engine!");
340 return CreateUndefined();
341 #endif
342 }
343
GetNamedProperty(JSIValue object,const char * const propName)344 JSIValue JSI::GetNamedProperty(JSIValue object, const char * const propName)
345 {
346 if (!ValueIsObject(object) || (propName == nullptr)) {
347 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetNamedProperty failed!");
348 return CreateUndefined();
349 }
350 #if (ENABLE_JERRY == 1)
351 jerry_value_t jKey = jerry_create_string(reinterpret_cast<const jerry_char_t *>(propName));
352 JSIValue result = GetProperty(object, AS_JSI_VALUE(jKey));
353 jerry_release_value(jKey);
354 return result;
355 #else
356 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetNamedProperty has not been implemented in this js engine!");
357 return CreateUndefined();
358 #endif
359 }
360
GetNumberProperty(JSIValue object,const char * const propName)361 double JSI::GetNumberProperty(JSIValue object, const char * const propName)
362 {
363 if (!ValueIsObject(object)) {
364 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetNumberProperty failed!");
365 return 0.0;
366 }
367 JSIValue propValue = GetNamedProperty(object, propName);
368 double res = ValueToNumber(propValue);
369 ReleaseValue(propValue);
370 return res;
371 }
372
GetBooleanProperty(JSIValue object,const char * const propName)373 bool JSI::GetBooleanProperty(JSIValue object, const char * const propName)
374 {
375 if (!ValueIsObject(object)) {
376 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetBooleanProperty failed!");
377 return false;
378 }
379 JSIValue propValue = GetNamedProperty(object, propName);
380 bool res = ValueToBoolean(propValue);
381 ReleaseValue(propValue);
382 return res;
383 }
384
GetStringProperty(JSIValue object,const char * const propName)385 char *JSI::GetStringProperty(JSIValue object, const char * const propName)
386 {
387 if (!ValueIsObject(object)) {
388 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetStringProperty failed!");
389 return nullptr;
390 }
391 JSIValue propValue = GetNamedProperty(object, propName);
392 char *res = ValueToString(propValue);
393 ReleaseValue(propValue);
394 return res;
395 }
396
GetStringPropertyWithBufferSize(JSIValue object,const char * const propName,size_t & size)397 char *JSI::GetStringPropertyWithBufferSize(JSIValue object, const char * const propName, size_t &size)
398 {
399 if (!ValueIsObject(object)) {
400 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetStringPropertyWithBufferSize failed!");
401 return nullptr;
402 }
403 JSIValue propValue = GetNamedProperty(object, propName);
404 char *res = ValueToStringWithBufferSize(propValue, size);
405 ReleaseValue(propValue);
406 return res;
407 }
408
ReleaseValue(JSIValue value)409 void JSI::ReleaseValue(JSIValue value)
410 {
411 #if (ENABLE_JERRY == 1)
412 if (value != ARGS_END) {
413 jerry_release_value(AS_JERRY_VALUE(value));
414 }
415 #else
416 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ReleaseValue has not been implemented in this js engine!");
417 #endif
418 }
419
ReleaseString(char * & str)420 void JSI::ReleaseString(char *&str)
421 {
422 if (str != nullptr) {
423 ace_free(str);
424 str = nullptr;
425 }
426 }
427
CallFunction(JSIValue funcObj,JSIValue thisVal,const JSIValue * argv,uint8_t argc)428 void JSI::CallFunction(JSIValue funcObj, JSIValue thisVal, const JSIValue *argv, uint8_t argc)
429 {
430 if (!ValueIsFunction(funcObj)) {
431 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction failed!");
432 return;
433 }
434 #if (ENABLE_JERRY == 1)
435 jerry_value_t jFunc = AS_JERRY_VALUE(funcObj);
436 jerry_value_t jThis = AS_JERRY_VALUE(thisVal);
437 if ((argv == nullptr) || argc == 0) {
438 jerry_value_t ret = jerry_call_function(jFunc, jThis, nullptr, 0);
439 if (jerry_value_is_error(ret)) {
440 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction error returned!");
441 }
442 jerry_release_value(ret);
443 return;
444 }
445 jerry_value_t *jArgv = new jerry_value_t[argc];
446 if (jArgv == nullptr) {
447 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction allocate memory failed!");
448 return;
449 }
450
451 for (uint8_t index = 0; index < argc; index++) {
452 jArgv[index] = AS_JERRY_VALUE(argv[index]);
453 }
454 jerry_value_t ret = jerry_call_function(jFunc, jThis, jArgv, argc);
455 if (jerry_value_is_error(ret)) {
456 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction error returned!");
457 }
458 jerry_release_value(ret);
459 delete[] jArgv;
460 jArgv = nullptr;
461 #else
462 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction has not been implemented in this js engine!");
463 #endif
464 }
465
CreateNumber(double value)466 JSIValue JSI::CreateNumber(double value)
467 {
468 #if (ENABLE_JERRY == 1)
469 return AS_JSI_VALUE(jerry_create_number(value));
470 #else
471 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateNumber has not been implemented in this js engine!");
472 return CreateUndefined();
473 #endif
474 }
475
CreateNumberNaN()476 JSIValue JSI::CreateNumberNaN()
477 {
478 #if (ENABLE_JERRY == 1)
479 return AS_JSI_VALUE(jerry_create_number_nan());
480 #else
481 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateNumberNan has not been implemented in this js engine!");
482 return CreateUndefined();
483 #endif
484 }
485
486 #if (ENABLE_JERRY == 1)
GetJerryErrorType(JsiErrorType jsiType)487 static jerry_error_t GetJerryErrorType(JsiErrorType jsiType)
488 {
489 jerry_error_t jerryType;
490 switch (jsiType) {
491 case JsiErrorType::JSI_ERROR_COMMON:
492 jerryType = JERRY_ERROR_COMMON;
493 break;
494 case JsiErrorType::JSI_ERROR_EVAL:
495 jerryType = JERRY_ERROR_EVAL;
496 break;
497 case JsiErrorType::JSI_ERROR_RANGE:
498 jerryType = JERRY_ERROR_RANGE;
499 break;
500 case JsiErrorType::JSI_ERROR_REFERENCE:
501 jerryType = JERRY_ERROR_REFERENCE;
502 break;
503 case JsiErrorType::JSI_ERROR_SYNTAX:
504 jerryType = JERRY_ERROR_SYNTAX;
505 break;
506 case JsiErrorType::JSI_ERROR_TYPE:
507 jerryType = JERRY_ERROR_TYPE;
508 break;
509 case JsiErrorType::JSI_ERROR_URI:
510 jerryType = JERRY_ERROR_URI;
511 break;
512 default:
513 jerryType = JERRY_ERROR_COMMON;
514 break;
515 }
516 return jerryType;
517 }
518
GetJsiErrorType(jerry_error_t jerryType)519 static JsiErrorType GetJsiErrorType(jerry_error_t jerryType)
520 {
521 JsiErrorType jsiType = static_cast<JsiErrorType>(jerryType);
522 if ((jsiType <= JsiErrorType::JSI_ERROR_INVALID) ||
523 (jsiType >= JsiErrorType::JSI_ERROR_MAX)) {
524 return JsiErrorType::JSI_ERROR_INVALID;
525 }
526 return jsiType;
527 }
528 #endif
529
CreateError(JsiErrorType type,const char * const errorMsg)530 JSIValue JSI::CreateError(JsiErrorType type, const char * const errorMsg)
531 {
532 if ((type <= JsiErrorType::JSI_ERROR_INVALID) ||
533 (type >= JsiErrorType::JSI_ERROR_MAX) || (errorMsg == nullptr)) {
534 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateError parameters invalid!");
535 return CreateUndefined();
536 }
537 #if (ENABLE_JERRY == 1)
538 jerry_error_t jerryType = GetJerryErrorType(type);
539 jerry_value_t jError = jerry_create_error(jerryType, reinterpret_cast<const jerry_char_t *>(errorMsg));
540 return AS_JSI_VALUE(jError);
541 #else
542 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateError has not been implemented in this js engine!");
543 return CreateUndefined();
544 #endif
545 }
546
GetErrorType(JSIValue errorValue)547 JsiErrorType JSI::GetErrorType(JSIValue errorValue)
548 {
549 if (!ValueIsError(errorValue)) {
550 return JsiErrorType::JSI_ERROR_INVALID;
551 }
552 #if (ENABLE_JERRY == 1)
553 jerry_value_t jError = AS_JERRY_VALUE(errorValue);
554 jerry_error_t jerryType = jerry_get_error_type(jError);
555 return GetJsiErrorType(jerryType);
556 #else
557 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetErrorType has not been implemented in this js engine!");
558 return JsiErrorType::JSI_ERROR_INVALID;
559 #endif
560 }
561
CreateBoolean(bool value)562 JSIValue JSI::CreateBoolean(bool value)
563 {
564 #if (ENABLE_JERRY == 1)
565 return AS_JSI_VALUE(jerry_create_boolean(value));
566 #else
567 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateBoolean has not been implemented in this js engine!");
568 return CreateUndefined();
569 #endif
570 }
571
CreateNull()572 JSIValue JSI::CreateNull()
573 {
574 #if (ENABLE_JERRY == 1)
575 return AS_JSI_VALUE(jerry_create_null());
576 #else
577 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateNull has not been implemented in this js engine!");
578 return CreateUndefined();
579 #endif
580 }
581
582 #if (JS_FWK_SYMBOL == 1)
CreateSymbol(JSIValue description)583 JSIValue JSI::CreateSymbol(JSIValue description)
584 {
585 #if (ENABLE_JERRY == 1)
586 jerry_value_t jDsc = AS_JERRY_VALUE(description);
587 return AS_JSI_VALUE(jerry_create_symbol(jDsc));
588 #else
589 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateSymbol has not been implemented in this js engine!");
590 return CreateUndefined();
591 #endif
592 }
593
ValueIsSymbol(JSIValue value)594 bool JSI::ValueIsSymbol(JSIValue value)
595 {
596 #if (ENABLE_JERRY == 1)
597 return jerry_value_is_symbol(AS_JERRY_VALUE(value));
598 #else
599 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsSymbol has not been implemented in this js engine!");
600 return false;
601 #endif
602 }
603 #endif // JS_FWK_SYMBOL
604
CreateArray(uint32_t length)605 JSIValue JSI::CreateArray(uint32_t length)
606 {
607 #if (ENABLE_JERRY == 1)
608 return AS_JSI_VALUE(jerry_create_array(length));
609 #else
610 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateArray has not been implemented in this js engine!");
611 return CreateUndefined();
612 #endif
613 }
614
SetPropertyByIndex(JSIValue object,uint32_t index,JSIValue value)615 bool JSI::SetPropertyByIndex(JSIValue object, uint32_t index, JSIValue value)
616 {
617 #if (ENABLE_JERRY == 1)
618 jerry_value_t jObject = AS_JERRY_VALUE(object);
619 jerry_value_t jVal = AS_JERRY_VALUE(value);
620
621 jerry_value_t res = jerry_set_property_by_index(jObject, index, jVal);
622 if (jerry_value_is_error(res)) {
623 jerry_release_value(res);
624 return false;
625 }
626 jerry_release_value(res);
627 return true;
628 #else
629 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetPropertyByIndex has not been implemented in this js engine!");
630 return false;
631 #endif
632 }
633
ValueToString(JSIValue value)634 char *JSI::ValueToString(JSIValue value)
635 {
636 #if (ENABLE_JERRY == 1)
637 char *result = nullptr;
638 jerry_value_t jVal = AS_JERRY_VALUE(value);
639 if (!jerry_value_is_string(jVal)) {
640 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString params invalid!");
641 return nullptr;
642 }
643
644 jerry_size_t size = jerry_get_string_size(jVal);
645 if ((size == 0) || (size == UINT32_MAX)) {
646 // Output empty char instead of nullptr, thus caller can free safely
647 result = static_cast<char *>(ace_malloc(sizeof(char)));
648 if (result == nullptr) {
649 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString malloc memory for empty char failed!");
650 return nullptr;
651 }
652 result[0] = '\0';
653 return result;
654 } else {
655 jerry_char_t *buffer = static_cast<jerry_char_t *>(ace_malloc(sizeof(jerry_char_t) * (size + 1)));
656 if (buffer == nullptr) {
657 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString malloc memory failed!");
658 return nullptr;
659 }
660 jerry_size_t length = jerry_string_to_char_buffer(jVal, buffer, size);
661 if ((length == 0) || (length > size)) {
662 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString jerry string to char buffer failed");
663 ace_free(buffer);
664 buffer = nullptr;
665 return nullptr;
666 }
667 buffer[length] = '\0';
668 result = reinterpret_cast<char *>(buffer);
669 return result;
670 }
671 #else
672 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString has not been implemented in this js engine!");
673 return nullptr;
674 #endif
675 }
676
ValueToStringWithBufferSize(JSIValue value,size_t & size)677 char *JSI::ValueToStringWithBufferSize(JSIValue value, size_t &size)
678 {
679 #if (ENABLE_JERRY == 1)
680 auto jVal = AS_JERRY_VALUE(value);
681 if (!jerry_value_is_string(jVal)) {
682 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToStringWithBufferSize params invalid!");
683 size = 0;
684 return nullptr;
685 }
686
687 size = jerry_get_string_size(jVal);
688 if ((size == 0) || (size == UINT32_MAX)) {
689 // Output nullptr
690 size = 0;
691 return nullptr;
692 } else {
693 auto *buffer = static_cast<jerry_char_t *>(ace_malloc(sizeof(jerry_char_t) * size));
694 if (buffer == nullptr) {
695 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToStringWithBufferSize malloc memory failed!");
696 size = 0;
697 return nullptr;
698 }
699 jerry_size_t length = jerry_string_to_char_buffer(jVal, buffer, size);
700 if ((length == 0) || (length > size)) {
701 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToStringWithBufferSize jerry string to char buffer failed");
702 ace_free(buffer);
703 size = 0;
704 return nullptr;
705 }
706 char *result = reinterpret_cast<char *>(buffer);
707 return result;
708 }
709 #else
710 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToStringWithBufferSize has not been implemented in this js engine!");
711 size = 0;
712 return nullptr;
713 #endif
714 }
715
ValueToNumber(JSIValue value)716 double JSI::ValueToNumber(JSIValue value)
717 {
718 #if (ENABLE_JERRY == 1)
719 jerry_value_t jVal = AS_JERRY_VALUE(value);
720 if (!jerry_value_is_number(jVal)) {
721 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToNumber params invalid!");
722 return 0.0;
723 }
724 return jerry_get_number_value(jVal);
725 #else
726 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToNumber has not been implemented in this js engine!");
727 return 0.0;
728 #endif
729 }
730
ValueToBoolean(JSIValue value)731 bool JSI::ValueToBoolean(JSIValue value)
732 {
733 #if (ENABLE_JERRY == 1)
734 jerry_value_t jVal = AS_JERRY_VALUE(value);
735 if (!jerry_value_is_boolean(jVal)) {
736 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToBoolean params invalid!");
737 return false;
738 }
739 return jerry_value_to_boolean(jVal);
740 #else
741 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToBoolean has not been implemented in this js engine!");
742 return false;
743 #endif
744 }
745
JSIValueToString(JSIValue value)746 char *JSI::JSIValueToString(JSIValue value)
747 {
748 #if (ENABLE_JERRY == 1)
749 jerry_value_t target = jerry_value_to_string(AS_JERRY_VALUE(value));
750 char *result = ValueToString(AS_JSI_VALUE(target));
751 jerry_release_value(target);
752 return result;
753 #else
754 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:JSIValueToString has not been implemented in this js engine!");
755 return nullptr;
756 #endif
757 }
758
GetArrayLength(JSIValue value)759 uint32_t JSI::GetArrayLength(JSIValue value)
760 {
761 #if (ENABLE_JERRY == 1)
762 jerry_value_t jVal = AS_JERRY_VALUE(value);
763 if (!jerry_value_is_array(jVal)) {
764 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetArrayLength params invalid!");
765 return 0;
766 }
767 return jerry_get_array_length(jVal);
768 #else
769 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetArrayLength has not been implemented in this js engine!");
770 return 0;
771 #endif
772 }
773
GetPropertyByIndex(JSIValue object,uint32_t index)774 JSIValue JSI::GetPropertyByIndex(JSIValue object, uint32_t index)
775 {
776 #if (ENABLE_JERRY == 1)
777 jerry_value_t jVal = AS_JERRY_VALUE(object);
778 return AS_JSI_VALUE(jerry_get_property_by_index(jVal, index));
779 #else
780 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetPropertyByIndex has not been implemented in this js engine!");
781 return CreateUndefined();
782 #endif
783 }
784
GetObjectKeys(JSIValue object)785 JSIValue JSI::GetObjectKeys(JSIValue object)
786 {
787 if (!ValueIsObject(object)) {
788 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetObjectKeys failed!");
789 return CreateUndefined();
790 }
791 #if (ENABLE_JERRY == 1)
792 jerry_value_t jVal = AS_JERRY_VALUE(object);
793 return AS_JSI_VALUE(jerry_get_object_keys(jVal));
794 #else
795 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetObjectKeys has not been implemented in this js engine!");
796 return CreateUndefined();
797 #endif
798 }
799
GetJSHeapStatus(JSHeapStatus & heapStatus)800 bool JSI::GetJSHeapStatus(JSHeapStatus &heapStatus)
801 {
802 #if (ENABLE_JERRY == 1)
803 jerry_heap_stats_t stats = {0};
804 if (!jerry_get_memory_stats(&stats)) {
805 return false;
806 }
807 heapStatus.totalBytes = stats.size;
808 heapStatus.allocBytes = stats.allocated_bytes;
809 heapStatus.peakAllocBytes = stats.peak_allocated_bytes;
810 return true;
811 #else
812 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetJSHeapStatus has not been implemented in this js engine!");
813 return false;
814 #endif
815 }
816
ValueIsArray(JSIValue value)817 bool JSI::ValueIsArray(JSIValue value)
818 {
819 #if (ENABLE_JERRY == 1)
820 return jerry_value_is_array(AS_JERRY_VALUE(value));
821 #else
822 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsArray has not been implemented in this js engine!");
823 return false;
824 #endif
825 }
826
AcquireValue(JSIValue value)827 JSIValue JSI::AcquireValue(JSIValue value)
828 {
829 #if (ENABLE_JERRY == 1)
830 jerry_value_t jVal = AS_JERRY_VALUE(value);
831 return AS_JSI_VALUE(jerry_acquire_value(jVal));
832 #else
833 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:AcquireValue has not been implemented in this js engine!");
834 return CreateUndefined();
835 #endif
836 }
837
SetModuleAPI(JSIValue exports,const char * const name,JSIFunctionHandler handler)838 void JSI::SetModuleAPI(JSIValue exports, const char * const name, JSIFunctionHandler handler)
839 {
840 if (!ValueIsObject(exports) || (handler == nullptr)) {
841 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetModuleAPI failed!");
842 return;
843 }
844 JSIValue jsFunc = CreateFunction(handler);
845 SetNamedProperty(exports, name, jsFunc);
846 ReleaseValue(jsFunc);
847 }
848
SetOnDestroy(JSIValue object,NativeCallback callback)849 void JSI::SetOnDestroy(JSIValue object, NativeCallback callback)
850 {
851 if (!ValueIsObject(object) || (callback == nullptr)) {
852 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetOnDestroy failed!");
853 return;
854 }
855 #if (ENABLE_JERRY == 1)
856 void *nativePtr = reinterpret_cast<void *>(callback);
857 jerry_set_object_native_pointer(AS_JERRY_VALUE(object), nativePtr, nullptr);
858 #else
859 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetOnDestroy has not been implemented in this js engine!");
860 #endif
861 }
862
SetOnDestroy(JSIValue object,JsiCallback callback)863 void JSI::SetOnDestroy(JSIValue object, JsiCallback callback)
864 {
865 SetNamedPointer(object, ON_DESTROY_HANDLER, callback);
866 }
867
SetOnTerminate(JSIValue object,NativeCallback callback)868 void JSI::SetOnTerminate(JSIValue object, NativeCallback callback)
869 {
870 if (!ValueIsObject(object) || (callback == nullptr)) {
871 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetOnTerminate failed!");
872 return;
873 }
874 JSIValue funObj = JSI::CreateObject();
875 JSI::SetOnDestroy(funObj, callback);
876 JSI::SetNamedProperty(object, ON_TERMINATE, funObj);
877 JSI::ReleaseValue(funObj);
878 }
879
SetOnTerminate(JSIValue object,JsiCallback callback)880 void JSI::SetOnTerminate(JSIValue object, JsiCallback callback)
881 {
882 SetNamedPointer(object, ON_TERMINATE_HANDLER, callback);
883 }
884
SetNamedPointer(JSIValue object,const char * const name,JsiCallback callback)885 void JSI::SetNamedPointer(JSIValue object, const char * const name, JsiCallback callback)
886 {
887 if (!ValueIsObject(object) || (callback == nullptr)) {
888 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetNamedPointer failed!");
889 return;
890 }
891 #if (ENABLE_JERRY == 1)
892 JSIValue funObj = JSI::CreateObject();
893 void *nativePtr = reinterpret_cast<void *>(callback);
894 jerry_set_object_native_pointer(AS_JERRY_VALUE(funObj), nativePtr, nullptr);
895 SetNamedProperty(object, name, funObj);
896 ReleaseValue(funObj);
897 #else
898 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetNamedPointer has not been implemented in this js engine!");
899 #endif
900 }
901
902 #if (JS_FWK_TYPEDARRAY == 1)
903 #if (ENABLE_JERRY == 1)
904 // Helper function for JSI TypedArray type convert
GetJsiArrayType(jerry_typedarray_type_t jerryType)905 TypedArrayType GetJsiArrayType(jerry_typedarray_type_t jerryType)
906 {
907 TypedArrayType jsiType;
908 switch (jerryType) {
909 case JERRY_TYPEDARRAY_INT8:
910 jsiType = TypedArrayType::JSI_INT8_ARRAY;
911 break;
912 case JERRY_TYPEDARRAY_UINT8:
913 jsiType = TypedArrayType::JSI_UINT8_ARRAY;
914 break;
915 case JERRY_TYPEDARRAY_UINT8CLAMPED:
916 jsiType = TypedArrayType::JSI_UINT8CLAMPED_ARRAY;
917 break;
918 case JERRY_TYPEDARRAY_INT16:
919 jsiType = TypedArrayType::JSI_INT16_ARRAY;
920 break;
921 case JERRY_TYPEDARRAY_UINT16:
922 jsiType = TypedArrayType::JSI_UINT16_ARRAY;
923 break;
924 case JERRY_TYPEDARRAY_INT32:
925 jsiType = TypedArrayType::JSI_INT32_ARRAY;
926 break;
927 case JERRY_TYPEDARRAY_UINT32:
928 jsiType = TypedArrayType::JSI_UINT32_ARRAY;
929 break;
930 case JERRY_TYPEDARRAY_FLOAT32:
931 jsiType = TypedArrayType::JSI_FLOAT32_ARRAY;
932 break;
933 case JERRY_TYPEDARRAY_FLOAT64:
934 jsiType = TypedArrayType::JSI_FLOAT64_ARRAY;
935 break;
936 default:
937 jsiType = TypedArrayType::JSI_INVALID_ARRAY;
938 break;
939 }
940 return jsiType;
941 }
942 #endif
943
GetTypedArrayInfo(JSIValue typedArray,TypedArrayType & type,size_t & length,JSIValue & arrayBuffer,size_t & byteOffset)944 uint8_t *JSI::GetTypedArrayInfo(JSIValue typedArray,
945 TypedArrayType &type,
946 size_t &length,
947 JSIValue &arrayBuffer,
948 size_t &byteOffset)
949 {
950 if (!ValueIsTypedArray(typedArray)) {
951 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetTypedArrayInfo failed!");
952 return nullptr;
953 }
954 #if (ENABLE_JERRY == 1)
955 jerry_value_t jVal = AS_JERRY_VALUE(typedArray);
956 jerry_typedarray_type_t jType = jerry_get_typedarray_type(jVal);
957 type = GetJsiArrayType(jType);
958
959 jerry_length_t jLength = jerry_get_typedarray_length(jVal);
960 jerry_length_t jByteOffset;
961 jerry_length_t jByteLength;
962 jerry_value_t jArrayBuffer = jerry_get_typedarray_buffer(jVal, &jByteOffset, &jByteLength);
963
964 length = (size_t)jLength;
965 arrayBuffer = AS_JSI_VALUE(jArrayBuffer);
966 byteOffset = (size_t)jByteOffset;
967 return jerry_get_arraybuffer_pointer(jArrayBuffer);
968 #else
969 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetTypedArrayInfo has not been implemented in this js engine!");
970 return nullptr;
971 #endif
972 }
973
974 #if (ENABLE_JERRY == 1)
975 // Helper function for jerry TypedArray type convert
GetJerryArrayType(TypedArrayType jsiType)976 jerry_typedarray_type_t GetJerryArrayType(TypedArrayType jsiType)
977 {
978 jerry_typedarray_type_t jerryType;
979 switch (jsiType) {
980 case TypedArrayType::JSI_INT8_ARRAY:
981 jerryType = JERRY_TYPEDARRAY_INT8;
982 break;
983 case TypedArrayType::JSI_UINT8_ARRAY:
984 jerryType = JERRY_TYPEDARRAY_UINT8;
985 break;
986 case TypedArrayType::JSI_UINT8CLAMPED_ARRAY:
987 jerryType = JERRY_TYPEDARRAY_UINT8CLAMPED;
988 break;
989 case TypedArrayType::JSI_INT16_ARRAY:
990 jerryType = JERRY_TYPEDARRAY_INT16;
991 break;
992 case TypedArrayType::JSI_UINT16_ARRAY:
993 jerryType = JERRY_TYPEDARRAY_UINT16;
994 break;
995 case TypedArrayType::JSI_INT32_ARRAY:
996 jerryType = JERRY_TYPEDARRAY_INT32;
997 break;
998 case TypedArrayType::JSI_UINT32_ARRAY:
999 jerryType = JERRY_TYPEDARRAY_UINT32;
1000 break;
1001 case TypedArrayType::JSI_FLOAT32_ARRAY:
1002 jerryType = JERRY_TYPEDARRAY_FLOAT32;
1003 break;
1004 case TypedArrayType::JSI_FLOAT64_ARRAY:
1005 jerryType = JERRY_TYPEDARRAY_FLOAT64;
1006 break;
1007 default:
1008 jerryType = JERRY_TYPEDARRAY_INVALID;
1009 break;
1010 }
1011 return jerryType;
1012 }
1013 #endif
1014
CreateTypedArray(TypedArrayType type,size_t length,JSIValue arrayBuffer,size_t byteOffset)1015 JSIValue JSI::CreateTypedArray(TypedArrayType type, size_t length, JSIValue arrayBuffer, size_t byteOffset)
1016 {
1017 #if (ENABLE_JERRY == 1)
1018 jerry_typedarray_type_t jType = GetJerryArrayType(type);
1019 jerry_value_t jArrayBuffer = AS_JERRY_VALUE(arrayBuffer);
1020 jerry_value_t jVal = jerry_create_typedarray_for_arraybuffer_sz(jType, jArrayBuffer, (jerry_length_t)byteOffset,
1021 (jerry_length_t)length);
1022 return AS_JSI_VALUE(jVal);
1023 #else
1024 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateTypedArray has not been implemented in this js engine!");
1025 return CreateUndefined();
1026 #endif
1027 }
1028
GetArrayBufferInfo(JSIValue arrayBuffer,size_t & byteLength)1029 uint8_t *JSI::GetArrayBufferInfo(JSIValue arrayBuffer, size_t &byteLength)
1030 {
1031 if (!ValueIsArrayBuffer(arrayBuffer)) {
1032 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetArrayBufferInfo failed!");
1033 return nullptr;
1034 }
1035 #if (ENABLE_JERRY == 1)
1036 jerry_value_t jVal = AS_JERRY_VALUE(arrayBuffer);
1037 jerry_length_t len = jerry_get_arraybuffer_byte_length(jVal);
1038
1039 byteLength = (size_t)len;
1040 return jerry_get_arraybuffer_pointer(jVal);
1041 #else
1042 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetArrayBufferInfo has not been implemented in this js engine!");
1043 return nullptr;
1044 #endif
1045 }
1046
CreateArrayBuffer(size_t byteLength,uint8_t * & buffPtr)1047 JSIValue JSI::CreateArrayBuffer(size_t byteLength, uint8_t *&buffPtr)
1048 {
1049 if (byteLength == 0) {
1050 return CreateUndefined();
1051 }
1052 #if (ENABLE_JERRY == 1)
1053 jerry_value_t jVal = jerry_create_arraybuffer((jerry_length_t)byteLength);
1054 buffPtr = jerry_get_arraybuffer_pointer(jVal);
1055 return AS_JSI_VALUE(jVal);
1056 #else
1057 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateArrayBuffer has not been implemented in this js engine!");
1058 return CreateUndefined();
1059 #endif
1060 }
1061
ValueIsArrayBuffer(JSIValue value)1062 bool JSI::ValueIsArrayBuffer(JSIValue value)
1063 {
1064 #if (ENABLE_JERRY == 1)
1065 return jerry_value_is_arraybuffer(AS_JERRY_VALUE(value));
1066 #else
1067 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsArrayBuffer has not been implemented in this js engine!");
1068 return false;
1069 #endif
1070 }
1071
ValueIsTypedArray(JSIValue value)1072 bool JSI::ValueIsTypedArray(JSIValue value)
1073 {
1074 #if (ENABLE_JERRY == 1)
1075 return jerry_value_is_typedarray(AS_JERRY_VALUE(value));
1076 #else
1077 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsTypedArray has not been implemented in this js engine!");
1078 return false;
1079 #endif
1080 }
1081 #endif // JS_FWK_TYPEDARRAY
1082
DefineProperty(JSIValue object,JSIValue propName,JSPropertyDescriptor descriptor)1083 bool JSI::DefineProperty(JSIValue object, JSIValue propName, JSPropertyDescriptor descriptor)
1084 {
1085 if (!ValueIsObject(object)) {
1086 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:DefineProperty failed!");
1087 return false;
1088 }
1089 #if (ENABLE_JERRY == 1)
1090 jerry_property_descriptor_t jerryDesc;
1091 jerry_init_property_descriptor_fields(&jerryDesc);
1092
1093 jerryDesc.is_set_defined = false;
1094 if (descriptor.setter != nullptr) {
1095 jerryDesc.is_set_defined = true;
1096 jerryDesc.setter = AS_JERRY_VALUE(CreateFunction(descriptor.setter));
1097 }
1098 jerryDesc.is_get_defined = false;
1099 if (descriptor.getter != nullptr) {
1100 jerryDesc.is_get_defined = true;
1101 jerryDesc.getter = AS_JERRY_VALUE(CreateFunction(descriptor.getter));
1102 }
1103 jerry_value_t retValue = jerry_define_own_property(AS_JERRY_VALUE(object), AS_JERRY_VALUE(propName), &jerryDesc);
1104 jerry_free_property_descriptor_fields(&jerryDesc);
1105
1106 bool res = true;
1107 if (jerry_value_is_error(retValue)) {
1108 res = false;
1109 }
1110 jerry_release_value(retValue);
1111 return res;
1112 #else
1113 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:DefineProperty has not been implemented in this js engine!");
1114 return false;
1115 #endif
1116 }
1117
DefineNamedProperty(JSIValue object,const char * const propNameStr,JSPropertyDescriptor descriptor)1118 bool JSI::DefineNamedProperty(JSIValue object, const char * const propNameStr, JSPropertyDescriptor descriptor)
1119 {
1120 if (!ValueIsObject(object) || (propNameStr == nullptr)) {
1121 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:DefineNamedProperty failed!");
1122 return false;
1123 }
1124 #if (ENABLE_JERRY == 1)
1125 jerry_value_t propName = jerry_create_string(reinterpret_cast<const jerry_char_t *>(propNameStr));
1126 bool res = DefineProperty(object, AS_JSI_VALUE(propName), descriptor);
1127 jerry_release_value(propName);
1128 return res;
1129 #else
1130 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:DefineNamedProperty has not been implemented in this js engine!");
1131 return false;
1132 #endif
1133 }
1134
DefineNamedProperty(JSIValue object,const char * const propNameStr,JSIFunctionHandler setter,JSIFunctionHandler getter)1135 bool JSI::DefineNamedProperty(JSIValue object,
1136 const char * const propNameStr,
1137 JSIFunctionHandler setter,
1138 JSIFunctionHandler getter)
1139 {
1140 JSPropertyDescriptor desc;
1141 desc.setter = setter;
1142 desc.getter = getter;
1143 return JSI::DefineNamedProperty(object, propNameStr, desc);
1144 }
1145
FailCallback(const JSIValue thisVal,const JSIValue args,int32_t errCode,const char * const errDesc)1146 void JSI::FailCallback(const JSIValue thisVal, const JSIValue args, int32_t errCode, const char * const errDesc)
1147 {
1148 if (ValueIsUndefined(args)) {
1149 return;
1150 }
1151 JSIValue fail = GetNamedProperty(args, CB_FAIL);
1152 JSIValue complete = GetNamedProperty(args, CB_COMPLETE);
1153 JSIValue errInfo = CreateString(errDesc);
1154 JSIValue retCode = CreateNumber(errCode);
1155 JSIValue argv[ARGC_TWO] = {errInfo, retCode};
1156
1157 CallFunction(fail, thisVal, argv, ARGC_TWO);
1158 CallFunction(complete, thisVal, nullptr, 0);
1159 ReleaseValueList(errInfo, retCode, fail, complete);
1160 }
1161
SuccessCallback(const JSIValue thisVal,const JSIValue args,const JSIValue * argv,uint8_t argc)1162 void JSI::SuccessCallback(const JSIValue thisVal, const JSIValue args, const JSIValue *argv, uint8_t argc)
1163 {
1164 if (ValueIsUndefined(args)) {
1165 return;
1166 }
1167 JSIValue success = GetNamedProperty(args, CB_SUCCESS);
1168 JSIValue complete = GetNamedProperty(args, CB_COMPLETE);
1169
1170 CallFunction(success, thisVal, argv, argc);
1171 CallFunction(complete, thisVal, nullptr, 0);
1172 ReleaseValueList(success, complete);
1173 }
1174
CreateErrorWithCode(uint32_t errCode,const char * const errMsg,const JSIValue extraErrData)1175 JSIValue JSI::CreateErrorWithCode(uint32_t errCode,
1176 const char * const errMsg,
1177 const JSIValue extraErrData)
1178 {
1179 if (errMsg == nullptr) {
1180 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateErrorWithCode parameters invalid!");
1181 return CreateUndefined();
1182 }
1183 const size_t maxErrMsgLength = 256;
1184 if (strlen(errMsg) > maxErrMsgLength) {
1185 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateErrorWithCode error message too long!");
1186 return CreateUndefined();
1187 }
1188 #if (ENABLE_JERRY == 1)
1189 JSIValue errObj = CreateObject();
1190 SetNumberProperty(errObj, "code", errCode);
1191 SetStringProperty(errObj, "message", errMsg);
1192 if (extraErrData != 0 && ValueIsObject(extraErrData)) {
1193 SetNamedProperty(errObj, "data", extraErrData);
1194 }
1195 jerry_value_t errRef = jerry_create_error_from_value(AS_JERRY_VALUE(errObj), true);
1196 return AS_JSI_VALUE(errRef);
1197 #else
1198 HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateErrorWithCode has not been implemented in this js engine!");
1199 return CreateUndefined();
1200 #endif
1201 }
1202 } // namespace ACELite
1203 } // namespace OHOS
1204