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         return;
432     }
433 #if (ENABLE_JERRY == 1)
434     jerry_value_t jFunc = AS_JERRY_VALUE(funcObj);
435     jerry_value_t jThis = AS_JERRY_VALUE(thisVal);
436     if ((argv == nullptr) || argc == 0) {
437         jerry_value_t ret = jerry_call_function(jFunc, jThis, nullptr, 0);
438         if (jerry_value_is_error(ret)) {
439             HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction error returned!");
440         }
441         jerry_release_value(ret);
442         return;
443     }
444     jerry_value_t *jArgv = new jerry_value_t[argc];
445     if (jArgv == nullptr) {
446         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction allocate memory failed!");
447         return;
448     }
449 
450     for (uint8_t index = 0; index < argc; index++) {
451         jArgv[index] = AS_JERRY_VALUE(argv[index]);
452     }
453     jerry_value_t ret = jerry_call_function(jFunc, jThis, jArgv, argc);
454     if (jerry_value_is_error(ret)) {
455         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction error returned!");
456     }
457     jerry_release_value(ret);
458     delete[] jArgv;
459     jArgv = nullptr;
460 #else
461     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CallFunction has not been implemented in this js engine!");
462 #endif
463 }
464 
CreateNumber(double value)465 JSIValue JSI::CreateNumber(double value)
466 {
467 #if (ENABLE_JERRY == 1)
468     return AS_JSI_VALUE(jerry_create_number(value));
469 #else
470     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateNumber has not been implemented in this js engine!");
471     return CreateUndefined();
472 #endif
473 }
474 
CreateNumberNaN()475 JSIValue JSI::CreateNumberNaN()
476 {
477 #if (ENABLE_JERRY == 1)
478     return AS_JSI_VALUE(jerry_create_number_nan());
479 #else
480     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateNumberNan has not been implemented in this js engine!");
481     return CreateUndefined();
482 #endif
483 }
484 
485 #if (ENABLE_JERRY == 1)
GetJerryErrorType(JsiErrorType jsiType)486 static jerry_error_t GetJerryErrorType(JsiErrorType jsiType)
487 {
488     jerry_error_t jerryType;
489     switch (jsiType) {
490         case JsiErrorType::JSI_ERROR_COMMON:
491             jerryType = JERRY_ERROR_COMMON;
492             break;
493         case JsiErrorType::JSI_ERROR_EVAL:
494             jerryType = JERRY_ERROR_EVAL;
495             break;
496         case JsiErrorType::JSI_ERROR_RANGE:
497             jerryType = JERRY_ERROR_RANGE;
498             break;
499         case JsiErrorType::JSI_ERROR_REFERENCE:
500             jerryType = JERRY_ERROR_REFERENCE;
501             break;
502         case JsiErrorType::JSI_ERROR_SYNTAX:
503             jerryType = JERRY_ERROR_SYNTAX;
504             break;
505         case JsiErrorType::JSI_ERROR_TYPE:
506             jerryType = JERRY_ERROR_TYPE;
507             break;
508         case JsiErrorType::JSI_ERROR_URI:
509             jerryType = JERRY_ERROR_URI;
510             break;
511         default:
512             jerryType = JERRY_ERROR_COMMON;
513             break;
514     }
515     return jerryType;
516 }
517 
GetJsiErrorType(jerry_error_t jerryType)518 static JsiErrorType GetJsiErrorType(jerry_error_t jerryType)
519 {
520     JsiErrorType jsiType = static_cast<JsiErrorType>(jerryType);
521     if ((jsiType <= JsiErrorType::JSI_ERROR_INVALID) ||
522         (jsiType >= JsiErrorType::JSI_ERROR_MAX)) {
523         return JsiErrorType::JSI_ERROR_INVALID;
524     }
525     return jsiType;
526 }
527 #endif
528 
CreateError(JsiErrorType type,const char * const errorMsg)529 JSIValue JSI::CreateError(JsiErrorType type, const char * const errorMsg)
530 {
531     if ((type <= JsiErrorType::JSI_ERROR_INVALID) ||
532         (type >= JsiErrorType::JSI_ERROR_MAX) || (errorMsg == nullptr)) {
533         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateError parameters invalid!");
534         return CreateUndefined();
535     }
536 #if (ENABLE_JERRY == 1)
537     jerry_error_t jerryType = GetJerryErrorType(type);
538     jerry_value_t jError = jerry_create_error(jerryType, reinterpret_cast<const jerry_char_t *>(errorMsg));
539     return AS_JSI_VALUE(jError);
540 #else
541     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateError has not been implemented in this js engine!");
542     return CreateUndefined();
543 #endif
544 }
545 
GetErrorType(JSIValue errorValue)546 JsiErrorType JSI::GetErrorType(JSIValue errorValue)
547 {
548     if (!ValueIsError(errorValue)) {
549         return JsiErrorType::JSI_ERROR_INVALID;
550     }
551 #if (ENABLE_JERRY == 1)
552     jerry_value_t jError = AS_JERRY_VALUE(errorValue);
553     jerry_error_t jerryType = jerry_get_error_type(jError);
554     return GetJsiErrorType(jerryType);
555 #else
556     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetErrorType has not been implemented in this js engine!");
557     return JsiErrorType::JSI_ERROR_INVALID;
558 #endif
559 }
560 
CreateBoolean(bool value)561 JSIValue JSI::CreateBoolean(bool value)
562 {
563 #if (ENABLE_JERRY == 1)
564     return AS_JSI_VALUE(jerry_create_boolean(value));
565 #else
566     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateBoolean has not been implemented in this js engine!");
567     return CreateUndefined();
568 #endif
569 }
570 
CreateNull()571 JSIValue JSI::CreateNull()
572 {
573 #if (ENABLE_JERRY == 1)
574     return AS_JSI_VALUE(jerry_create_null());
575 #else
576     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateNull has not been implemented in this js engine!");
577     return CreateUndefined();
578 #endif
579 }
580 
581 #if (JS_FWK_SYMBOL == 1)
CreateSymbol(JSIValue description)582 JSIValue JSI::CreateSymbol(JSIValue description)
583 {
584 #if (ENABLE_JERRY == 1)
585     jerry_value_t jDsc = AS_JERRY_VALUE(description);
586     return AS_JSI_VALUE(jerry_create_symbol(jDsc));
587 #else
588     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateSymbol has not been implemented in this js engine!");
589     return CreateUndefined();
590 #endif
591 }
592 
ValueIsSymbol(JSIValue value)593 bool JSI::ValueIsSymbol(JSIValue value)
594 {
595 #if (ENABLE_JERRY == 1)
596     return jerry_value_is_symbol(AS_JERRY_VALUE(value));
597 #else
598     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsSymbol has not been implemented in this js engine!");
599     return false;
600 #endif
601 }
602 #endif // JS_FWK_SYMBOL
603 
CreateArray(uint32_t length)604 JSIValue JSI::CreateArray(uint32_t length)
605 {
606 #if (ENABLE_JERRY == 1)
607     return AS_JSI_VALUE(jerry_create_array(length));
608 #else
609     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateArray has not been implemented in this js engine!");
610     return CreateUndefined();
611 #endif
612 }
613 
SetPropertyByIndex(JSIValue object,uint32_t index,JSIValue value)614 bool JSI::SetPropertyByIndex(JSIValue object, uint32_t index, JSIValue value)
615 {
616 #if (ENABLE_JERRY == 1)
617     jerry_value_t jObject = AS_JERRY_VALUE(object);
618     jerry_value_t jVal = AS_JERRY_VALUE(value);
619 
620     jerry_value_t res = jerry_set_property_by_index(jObject, index, jVal);
621     if (jerry_value_is_error(res)) {
622         jerry_release_value(res);
623         return false;
624     }
625     jerry_release_value(res);
626     return true;
627 #else
628     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetPropertyByIndex has not been implemented in this js engine!");
629     return false;
630 #endif
631 }
632 
ValueToString(JSIValue value)633 char *JSI::ValueToString(JSIValue value)
634 {
635 #if (ENABLE_JERRY == 1)
636     char *result = nullptr;
637     jerry_value_t jVal = AS_JERRY_VALUE(value);
638     if (!jerry_value_is_string(jVal)) {
639         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString params invalid!");
640         return nullptr;
641     }
642 
643     jerry_size_t size = jerry_get_string_size(jVal);
644     if ((size == 0) || (size == UINT32_MAX)) {
645         // Output empty char instead of nullptr, thus caller can free safely
646         result = static_cast<char *>(ace_malloc(sizeof(char)));
647         if (result == nullptr) {
648             HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString malloc memory for empty char failed!");
649             return nullptr;
650         }
651         result[0] = '\0';
652         return result;
653     } else {
654         jerry_char_t *buffer = static_cast<jerry_char_t *>(ace_malloc(sizeof(jerry_char_t) * (size + 1)));
655         if (buffer == nullptr) {
656             HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString malloc memory failed!");
657             return nullptr;
658         }
659         jerry_size_t length = jerry_string_to_char_buffer(jVal, buffer, size);
660         if ((length == 0) || (length > size)) {
661             HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString jerry string to char buffer failed");
662             ace_free(buffer);
663             buffer = nullptr;
664             return nullptr;
665         }
666         buffer[length] = '\0';
667         result = reinterpret_cast<char *>(buffer);
668         return result;
669     }
670 #else
671     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToString has not been implemented in this js engine!");
672     return nullptr;
673 #endif
674 }
675 
ValueToStringWithBufferSize(JSIValue value,size_t & size)676 char *JSI::ValueToStringWithBufferSize(JSIValue value, size_t &size)
677 {
678 #if (ENABLE_JERRY == 1)
679     auto jVal = AS_JERRY_VALUE(value);
680     if (!jerry_value_is_string(jVal)) {
681         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToStringWithBufferSize params invalid!");
682         size = 0;
683         return nullptr;
684     }
685 
686     size = jerry_get_string_size(jVal);
687     if ((size == 0) || (size == UINT32_MAX)) {
688         // Output nullptr
689         size = 0;
690         return nullptr;
691     } else {
692         auto *buffer = static_cast<jerry_char_t *>(ace_malloc(sizeof(jerry_char_t) * size));
693         if (buffer == nullptr) {
694             HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToStringWithBufferSize malloc memory failed!");
695             size = 0;
696             return nullptr;
697         }
698         jerry_size_t length = jerry_string_to_char_buffer(jVal, buffer, size);
699         if ((length == 0) || (length > size)) {
700             HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToStringWithBufferSize jerry string to char buffer failed");
701             ace_free(buffer);
702             size = 0;
703             return nullptr;
704         }
705         char *result = reinterpret_cast<char *>(buffer);
706         return result;
707     }
708 #else
709     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToStringWithBufferSize has not been implemented in this js engine!");
710     size = 0;
711     return nullptr;
712 #endif
713 }
714 
ValueToNumber(JSIValue value)715 double JSI::ValueToNumber(JSIValue value)
716 {
717 #if (ENABLE_JERRY == 1)
718     jerry_value_t jVal = AS_JERRY_VALUE(value);
719     if (!jerry_value_is_number(jVal)) {
720         HILOG_INFO(HILOG_MODULE_ACE, "JSI:ValueToNumber params invalid!");
721         return 0.0;
722     }
723     return jerry_get_number_value(jVal);
724 #else
725     HILOG_INFO(HILOG_MODULE_ACE, "JSI:ValueToNumber has not been implemented in this js engine!");
726     return 0.0;
727 #endif
728 }
729 
ValueToBoolean(JSIValue value)730 bool JSI::ValueToBoolean(JSIValue value)
731 {
732 #if (ENABLE_JERRY == 1)
733     jerry_value_t jVal = AS_JERRY_VALUE(value);
734     if (!jerry_value_is_boolean(jVal)) {
735         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToBoolean params invalid!");
736         return false;
737     }
738     return jerry_value_to_boolean(jVal);
739 #else
740     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueToBoolean has not been implemented in this js engine!");
741     return false;
742 #endif
743 }
744 
JSIValueToString(JSIValue value)745 char *JSI::JSIValueToString(JSIValue value)
746 {
747 #if (ENABLE_JERRY == 1)
748     jerry_value_t target = jerry_value_to_string(AS_JERRY_VALUE(value));
749     char *result = ValueToString(AS_JSI_VALUE(target));
750     jerry_release_value(target);
751     return result;
752 #else
753     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:JSIValueToString has not been implemented in this js engine!");
754     return nullptr;
755 #endif
756 }
757 
GetArrayLength(JSIValue value)758 uint32_t JSI::GetArrayLength(JSIValue value)
759 {
760 #if (ENABLE_JERRY == 1)
761     jerry_value_t jVal = AS_JERRY_VALUE(value);
762     if (!jerry_value_is_array(jVal)) {
763         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetArrayLength params invalid!");
764         return 0;
765     }
766     return jerry_get_array_length(jVal);
767 #else
768     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetArrayLength has not been implemented in this js engine!");
769     return 0;
770 #endif
771 }
772 
GetPropertyByIndex(JSIValue object,uint32_t index)773 JSIValue JSI::GetPropertyByIndex(JSIValue object, uint32_t index)
774 {
775 #if (ENABLE_JERRY == 1)
776     jerry_value_t jVal = AS_JERRY_VALUE(object);
777     return AS_JSI_VALUE(jerry_get_property_by_index(jVal, index));
778 #else
779     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetPropertyByIndex has not been implemented in this js engine!");
780     return CreateUndefined();
781 #endif
782 }
783 
GetObjectKeys(JSIValue object)784 JSIValue JSI::GetObjectKeys(JSIValue object)
785 {
786     if (!ValueIsObject(object)) {
787         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetObjectKeys failed!");
788         return CreateUndefined();
789     }
790 #if (ENABLE_JERRY == 1)
791     jerry_value_t jVal = AS_JERRY_VALUE(object);
792     return AS_JSI_VALUE(jerry_get_object_keys(jVal));
793 #else
794     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetObjectKeys has not been implemented in this js engine!");
795     return CreateUndefined();
796 #endif
797 }
798 
GetJSHeapStatus(JSHeapStatus & heapStatus)799 bool JSI::GetJSHeapStatus(JSHeapStatus &heapStatus)
800 {
801 #if (ENABLE_JERRY == 1)
802     jerry_heap_stats_t stats = {0};
803     if (!jerry_get_memory_stats(&stats)) {
804         return false;
805     }
806     heapStatus.totalBytes = stats.size;
807     heapStatus.allocBytes = stats.allocated_bytes;
808     heapStatus.peakAllocBytes = stats.peak_allocated_bytes;
809     return true;
810 #else
811     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetJSHeapStatus has not been implemented in this js engine!");
812     return false;
813 #endif
814 }
815 
ValueIsArray(JSIValue value)816 bool JSI::ValueIsArray(JSIValue value)
817 {
818 #if (ENABLE_JERRY == 1)
819     return jerry_value_is_array(AS_JERRY_VALUE(value));
820 #else
821     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsArray has not been implemented in this js engine!");
822     return false;
823 #endif
824 }
825 
AcquireValue(JSIValue value)826 JSIValue JSI::AcquireValue(JSIValue value)
827 {
828 #if (ENABLE_JERRY == 1)
829     jerry_value_t jVal = AS_JERRY_VALUE(value);
830     return AS_JSI_VALUE(jerry_acquire_value(jVal));
831 #else
832     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:AcquireValue has not been implemented in this js engine!");
833     return CreateUndefined();
834 #endif
835 }
836 
SetModuleAPI(JSIValue exports,const char * const name,JSIFunctionHandler handler)837 void JSI::SetModuleAPI(JSIValue exports, const char * const name, JSIFunctionHandler handler)
838 {
839     if (!ValueIsObject(exports) || (handler == nullptr)) {
840         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetModuleAPI failed!");
841         return;
842     }
843     JSIValue jsFunc = CreateFunction(handler);
844     SetNamedProperty(exports, name, jsFunc);
845     ReleaseValue(jsFunc);
846 }
847 
SetOnDestroy(JSIValue object,NativeCallback callback)848 void JSI::SetOnDestroy(JSIValue object, NativeCallback callback)
849 {
850     if (!ValueIsObject(object) || (callback == nullptr)) {
851         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetOnDestroy failed!");
852         return;
853     }
854 #if (ENABLE_JERRY == 1)
855     void *nativePtr = reinterpret_cast<void *>(callback);
856     jerry_set_object_native_pointer(AS_JERRY_VALUE(object), nativePtr, nullptr);
857 #else
858     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetOnDestroy has not been implemented in this js engine!");
859 #endif
860 }
861 
SetOnDestroy(JSIValue object,JsiCallback callback)862 void JSI::SetOnDestroy(JSIValue object, JsiCallback callback)
863 {
864     SetNamedPointer(object, ON_DESTROY_HANDLER, callback);
865 }
866 
SetOnTerminate(JSIValue object,NativeCallback callback)867 void JSI::SetOnTerminate(JSIValue object, NativeCallback callback)
868 {
869     if (!ValueIsObject(object) || (callback == nullptr)) {
870         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetOnTerminate failed!");
871         return;
872     }
873     JSIValue funObj = JSI::CreateObject();
874     JSI::SetOnDestroy(funObj, callback);
875     JSI::SetNamedProperty(object, ON_TERMINATE, funObj);
876     JSI::ReleaseValue(funObj);
877 }
878 
SetOnTerminate(JSIValue object,JsiCallback callback)879 void JSI::SetOnTerminate(JSIValue object, JsiCallback callback)
880 {
881     SetNamedPointer(object, ON_TERMINATE_HANDLER, callback);
882 }
883 
SetNamedPointer(JSIValue object,const char * const name,JsiCallback callback)884 void JSI::SetNamedPointer(JSIValue object, const char * const name, JsiCallback callback)
885 {
886     if (!ValueIsObject(object) || (callback == nullptr)) {
887         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetNamedPointer failed!");
888         return;
889     }
890 #if (ENABLE_JERRY == 1)
891     JSIValue funObj = JSI::CreateObject();
892     void *nativePtr = reinterpret_cast<void *>(callback);
893     jerry_set_object_native_pointer(AS_JERRY_VALUE(funObj), nativePtr, nullptr);
894     SetNamedProperty(object, name, funObj);
895     ReleaseValue(funObj);
896 #else
897     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:SetNamedPointer has not been implemented in this js engine!");
898 #endif
899 }
900 
901 #if (JS_FWK_TYPEDARRAY == 1)
902 #if (ENABLE_JERRY == 1)
903 // Helper function for JSI TypedArray type convert
GetJsiArrayType(jerry_typedarray_type_t jerryType)904 TypedArrayType GetJsiArrayType(jerry_typedarray_type_t jerryType)
905 {
906     TypedArrayType jsiType;
907     switch (jerryType) {
908         case JERRY_TYPEDARRAY_INT8:
909             jsiType = TypedArrayType::JSI_INT8_ARRAY;
910             break;
911         case JERRY_TYPEDARRAY_UINT8:
912             jsiType = TypedArrayType::JSI_UINT8_ARRAY;
913             break;
914         case JERRY_TYPEDARRAY_UINT8CLAMPED:
915             jsiType = TypedArrayType::JSI_UINT8CLAMPED_ARRAY;
916             break;
917         case JERRY_TYPEDARRAY_INT16:
918             jsiType = TypedArrayType::JSI_INT16_ARRAY;
919             break;
920         case JERRY_TYPEDARRAY_UINT16:
921             jsiType = TypedArrayType::JSI_UINT16_ARRAY;
922             break;
923         case JERRY_TYPEDARRAY_INT32:
924             jsiType = TypedArrayType::JSI_INT32_ARRAY;
925             break;
926         case JERRY_TYPEDARRAY_UINT32:
927             jsiType = TypedArrayType::JSI_UINT32_ARRAY;
928             break;
929         case JERRY_TYPEDARRAY_FLOAT32:
930             jsiType = TypedArrayType::JSI_FLOAT32_ARRAY;
931             break;
932         case JERRY_TYPEDARRAY_FLOAT64:
933             jsiType = TypedArrayType::JSI_FLOAT64_ARRAY;
934             break;
935         default:
936             jsiType = TypedArrayType::JSI_INVALID_ARRAY;
937             break;
938     }
939     return jsiType;
940 }
941 #endif
942 
GetTypedArrayInfo(JSIValue typedArray,TypedArrayType & type,size_t & length,JSIValue & arrayBuffer,size_t & byteOffset)943 uint8_t *JSI::GetTypedArrayInfo(JSIValue typedArray,
944                                 TypedArrayType &type,
945                                 size_t &length,
946                                 JSIValue &arrayBuffer,
947                                 size_t &byteOffset)
948 {
949     if (!ValueIsTypedArray(typedArray)) {
950         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetTypedArrayInfo failed!");
951         return nullptr;
952     }
953 #if (ENABLE_JERRY == 1)
954     jerry_value_t jVal = AS_JERRY_VALUE(typedArray);
955     jerry_typedarray_type_t jType = jerry_get_typedarray_type(jVal);
956     type = GetJsiArrayType(jType);
957 
958     jerry_length_t jLength = jerry_get_typedarray_length(jVal);
959     jerry_length_t jByteOffset;
960     jerry_length_t jByteLength;
961     jerry_value_t jArrayBuffer = jerry_get_typedarray_buffer(jVal, &jByteOffset, &jByteLength);
962 
963     length = (size_t)jLength;
964     arrayBuffer = AS_JSI_VALUE(jArrayBuffer);
965     byteOffset = (size_t)jByteOffset;
966     return jerry_get_arraybuffer_pointer(jArrayBuffer);
967 #else
968     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetTypedArrayInfo has not been implemented in this js engine!");
969     return nullptr;
970 #endif
971 }
972 
973 #if (ENABLE_JERRY == 1)
974 // Helper function for jerry TypedArray type convert
GetJerryArrayType(TypedArrayType jsiType)975 jerry_typedarray_type_t GetJerryArrayType(TypedArrayType jsiType)
976 {
977     jerry_typedarray_type_t jerryType;
978     switch (jsiType) {
979         case TypedArrayType::JSI_INT8_ARRAY:
980             jerryType = JERRY_TYPEDARRAY_INT8;
981             break;
982         case TypedArrayType::JSI_UINT8_ARRAY:
983             jerryType = JERRY_TYPEDARRAY_UINT8;
984             break;
985         case TypedArrayType::JSI_UINT8CLAMPED_ARRAY:
986             jerryType = JERRY_TYPEDARRAY_UINT8CLAMPED;
987             break;
988         case TypedArrayType::JSI_INT16_ARRAY:
989             jerryType = JERRY_TYPEDARRAY_INT16;
990             break;
991         case TypedArrayType::JSI_UINT16_ARRAY:
992             jerryType = JERRY_TYPEDARRAY_UINT16;
993             break;
994         case TypedArrayType::JSI_INT32_ARRAY:
995             jerryType = JERRY_TYPEDARRAY_INT32;
996             break;
997         case TypedArrayType::JSI_UINT32_ARRAY:
998             jerryType = JERRY_TYPEDARRAY_UINT32;
999             break;
1000         case TypedArrayType::JSI_FLOAT32_ARRAY:
1001             jerryType = JERRY_TYPEDARRAY_FLOAT32;
1002             break;
1003         case TypedArrayType::JSI_FLOAT64_ARRAY:
1004             jerryType = JERRY_TYPEDARRAY_FLOAT64;
1005             break;
1006         default:
1007             jerryType = JERRY_TYPEDARRAY_INVALID;
1008             break;
1009     }
1010     return jerryType;
1011 }
1012 #endif
1013 
CreateTypedArray(TypedArrayType type,size_t length,JSIValue arrayBuffer,size_t byteOffset)1014 JSIValue JSI::CreateTypedArray(TypedArrayType type, size_t length, JSIValue arrayBuffer, size_t byteOffset)
1015 {
1016 #if (ENABLE_JERRY == 1)
1017     jerry_typedarray_type_t jType = GetJerryArrayType(type);
1018     jerry_value_t jArrayBuffer = AS_JERRY_VALUE(arrayBuffer);
1019     jerry_value_t jVal = jerry_create_typedarray_for_arraybuffer_sz(jType, jArrayBuffer, (jerry_length_t)byteOffset,
1020                                                                     (jerry_length_t)length);
1021     return AS_JSI_VALUE(jVal);
1022 #else
1023     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateTypedArray has not been implemented in this js engine!");
1024     return CreateUndefined();
1025 #endif
1026 }
1027 
GetArrayBufferInfo(JSIValue arrayBuffer,size_t & byteLength)1028 uint8_t *JSI::GetArrayBufferInfo(JSIValue arrayBuffer, size_t &byteLength)
1029 {
1030     if (!ValueIsArrayBuffer(arrayBuffer)) {
1031         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetArrayBufferInfo failed!");
1032         return nullptr;
1033     }
1034 #if (ENABLE_JERRY == 1)
1035     jerry_value_t jVal = AS_JERRY_VALUE(arrayBuffer);
1036     jerry_length_t len = jerry_get_arraybuffer_byte_length(jVal);
1037 
1038     byteLength = (size_t)len;
1039     return jerry_get_arraybuffer_pointer(jVal);
1040 #else
1041     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:GetArrayBufferInfo has not been implemented in this js engine!");
1042     return nullptr;
1043 #endif
1044 }
1045 
CreateArrayBuffer(size_t byteLength,uint8_t * & buffPtr)1046 JSIValue JSI::CreateArrayBuffer(size_t byteLength, uint8_t *&buffPtr)
1047 {
1048     if (byteLength == 0) {
1049         return CreateUndefined();
1050     }
1051 #if (ENABLE_JERRY == 1)
1052     jerry_value_t jVal = jerry_create_arraybuffer((jerry_length_t)byteLength);
1053     buffPtr = jerry_get_arraybuffer_pointer(jVal);
1054     return AS_JSI_VALUE(jVal);
1055 #else
1056     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateArrayBuffer has not been implemented in this js engine!");
1057     return CreateUndefined();
1058 #endif
1059 }
1060 
ValueIsArrayBuffer(JSIValue value)1061 bool JSI::ValueIsArrayBuffer(JSIValue value)
1062 {
1063 #if (ENABLE_JERRY == 1)
1064     return jerry_value_is_arraybuffer(AS_JERRY_VALUE(value));
1065 #else
1066     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsArrayBuffer has not been implemented in this js engine!");
1067     return false;
1068 #endif
1069 }
1070 
ValueIsTypedArray(JSIValue value)1071 bool JSI::ValueIsTypedArray(JSIValue value)
1072 {
1073 #if (ENABLE_JERRY == 1)
1074     return jerry_value_is_typedarray(AS_JERRY_VALUE(value));
1075 #else
1076     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:ValueIsTypedArray has not been implemented in this js engine!");
1077     return false;
1078 #endif
1079 }
1080 #endif // JS_FWK_TYPEDARRAY
1081 
DefineProperty(JSIValue object,JSIValue propName,JSPropertyDescriptor descriptor)1082 bool JSI::DefineProperty(JSIValue object, JSIValue propName, JSPropertyDescriptor descriptor)
1083 {
1084     if (!ValueIsObject(object)) {
1085         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:DefineProperty failed!");
1086         return false;
1087     }
1088 #if (ENABLE_JERRY == 1)
1089     jerry_property_descriptor_t jerryDesc;
1090     jerry_init_property_descriptor_fields(&jerryDesc);
1091 
1092     jerryDesc.is_set_defined = false;
1093     if (descriptor.setter != nullptr) {
1094         jerryDesc.is_set_defined = true;
1095         jerryDesc.setter = AS_JERRY_VALUE(CreateFunction(descriptor.setter));
1096     }
1097     jerryDesc.is_get_defined = false;
1098     if (descriptor.getter != nullptr) {
1099         jerryDesc.is_get_defined = true;
1100         jerryDesc.getter = AS_JERRY_VALUE(CreateFunction(descriptor.getter));
1101     }
1102     jerry_value_t retValue = jerry_define_own_property(AS_JERRY_VALUE(object), AS_JERRY_VALUE(propName), &jerryDesc);
1103     jerry_free_property_descriptor_fields(&jerryDesc);
1104 
1105     bool res = true;
1106     if (jerry_value_is_error(retValue)) {
1107         res = false;
1108     }
1109     jerry_release_value(retValue);
1110     return res;
1111 #else
1112     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:DefineProperty has not been implemented in this js engine!");
1113     return false;
1114 #endif
1115 }
1116 
DefineNamedProperty(JSIValue object,const char * const propNameStr,JSPropertyDescriptor descriptor)1117 bool JSI::DefineNamedProperty(JSIValue object, const char * const propNameStr, JSPropertyDescriptor descriptor)
1118 {
1119     if (!ValueIsObject(object) || (propNameStr == nullptr)) {
1120         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:DefineNamedProperty failed!");
1121         return false;
1122     }
1123 #if (ENABLE_JERRY == 1)
1124     jerry_value_t propName = jerry_create_string(reinterpret_cast<const jerry_char_t *>(propNameStr));
1125     bool res = DefineProperty(object, AS_JSI_VALUE(propName), descriptor);
1126     jerry_release_value(propName);
1127     return res;
1128 #else
1129     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:DefineNamedProperty has not been implemented in this js engine!");
1130     return false;
1131 #endif
1132 }
1133 
DefineNamedProperty(JSIValue object,const char * const propNameStr,JSIFunctionHandler setter,JSIFunctionHandler getter)1134 bool JSI::DefineNamedProperty(JSIValue object,
1135                               const char * const propNameStr,
1136                               JSIFunctionHandler setter,
1137                               JSIFunctionHandler getter)
1138 {
1139     JSPropertyDescriptor desc;
1140     desc.setter = setter;
1141     desc.getter = getter;
1142     return JSI::DefineNamedProperty(object, propNameStr, desc);
1143 }
1144 
FailCallback(const JSIValue thisVal,const JSIValue args,int32_t errCode,const char * const errDesc)1145 void JSI::FailCallback(const JSIValue thisVal, const JSIValue args, int32_t errCode, const char * const errDesc)
1146 {
1147     if (ValueIsUndefined(args)) {
1148         return;
1149     }
1150     JSIValue fail = GetNamedProperty(args, CB_FAIL);
1151     JSIValue complete = GetNamedProperty(args, CB_COMPLETE);
1152     JSIValue errInfo = CreateString(errDesc);
1153     JSIValue retCode = CreateNumber(errCode);
1154     JSIValue argv[ARGC_TWO] = {errInfo, retCode};
1155 
1156     CallFunction(fail, thisVal, argv, ARGC_TWO);
1157     CallFunction(complete, thisVal, nullptr, 0);
1158     ReleaseValueList(errInfo, retCode, fail, complete);
1159 }
1160 
SuccessCallback(const JSIValue thisVal,const JSIValue args,const JSIValue * argv,uint8_t argc)1161 void JSI::SuccessCallback(const JSIValue thisVal, const JSIValue args, const JSIValue *argv, uint8_t argc)
1162 {
1163     if (ValueIsUndefined(args)) {
1164         return;
1165     }
1166     JSIValue success = GetNamedProperty(args, CB_SUCCESS);
1167     JSIValue complete = GetNamedProperty(args, CB_COMPLETE);
1168 
1169     CallFunction(success, thisVal, argv, argc);
1170     CallFunction(complete, thisVal, nullptr, 0);
1171     ReleaseValueList(success, complete);
1172 }
1173 
CreateErrorWithCode(uint32_t errCode,const char * const errMsg,const JSIValue extraErrData)1174 JSIValue JSI::CreateErrorWithCode(uint32_t errCode,
1175                                   const char * const errMsg,
1176                                   const JSIValue extraErrData)
1177 {
1178     if (errMsg == nullptr) {
1179         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateErrorWithCode parameters invalid!");
1180         return CreateUndefined();
1181     }
1182     const size_t maxErrMsgLength = 256;
1183     if (strlen(errMsg) > maxErrMsgLength) {
1184         HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateErrorWithCode error message too long!");
1185         return CreateUndefined();
1186     }
1187 #if (ENABLE_JERRY == 1)
1188     JSIValue errObj = CreateObject();
1189     SetNumberProperty(errObj, "code", errCode);
1190     SetStringProperty(errObj, "message", errMsg);
1191     if (extraErrData != 0 && ValueIsObject(extraErrData)) {
1192         SetNamedProperty(errObj, "data", extraErrData);
1193     }
1194     jerry_value_t errRef = jerry_create_error_from_value(AS_JERRY_VALUE(errObj), true);
1195     return AS_JSI_VALUE(errRef);
1196 #else
1197     HILOG_ERROR(HILOG_MODULE_ACE, "JSI:CreateErrorWithCode has not been implemented in this js engine!");
1198     return CreateUndefined();
1199 #endif
1200 }
1201 } // namespace ACELite
1202 } // namespace OHOS
1203