1 /*
2  * Copyright (c) 2024 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 "ark_interop_napi.h"
17 
18 #include <thread>
19 #include <ecmascript/js_tagged_value.h>
20 
21 #include "ark_interop_external.h"
22 #include "ark_interop_internal.h"
23 #include "ark_interop_log.h"
24 #include "ark_interop_scope.h"
25 #include "securec.h"
26 
27 #ifdef ERROR
28 #undef ERROR
29 #endif
30 
31 using namespace panda;
32 using namespace panda::ecmascript;
33 
ARKTSInner_ReportJSErrors(ARKTS_Env env,bool abortIfUnhandled)34 bool ARKTSInner_ReportJSErrors(ARKTS_Env env, bool abortIfUnhandled)
35 {
36     auto vm = P_CAST(env, EcmaVM*);
37     if (!JSNApi::HasPendingException(vm)) {
38         return false;
39     }
40 
41     auto exception = JSNApi::GetAndClearUncaughtException(vm);
42     auto jError = ARKTS_FromHandle(exception);
43 
44     // throw CJ exception
45     ARKTSInner_ThrowJSErrorToCJ(env, jError);
46 
47     return true;
48 }
49 
ARKTSInner_ReportNativeError(const char * format,...)50 void ARKTSInner_ReportNativeError(const char* format, ...)
51 {
52     constexpr size_t MAX_MESSAGE_SIZE = 0x100;
53     char buffer[MAX_MESSAGE_SIZE];
54 
55     va_list args;
56     va_start(args, format);
57 #ifdef __clang__
58     /* code specific to clang compiler */
59 #pragma clang diagnostic push
60 #pragma clang diagnostic ignored "-Wformat-nonliteral"
61 #elif __GNUC__
62     /* code for GNU C compiler */
63 #pragma GCC diagnostic push
64 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
65 #endif
66     int ret = vsnprintf_s(buffer, sizeof(buffer) / sizeof(char), MAX_MESSAGE_SIZE - 1, format, args);
67 #ifdef __clang__
68 #pragma clang diagnostic pop
69 #elif __GNUC__
70 #pragma GCC diagnostic pop
71 #endif
72     va_end(args);
73     const char* formatMsg;
74 
75     if (ret == -1) {
76         formatMsg = format;
77     } else {
78         buffer[ret] = '\0';
79         formatMsg = buffer;
80     }
81     ARKTSInner_ThrowNativeErrorToCJ(formatMsg);
82 }
83 
ARKTSInner_FormatJSError(ARKTS_Env env,ARKTS_Value jsError)84 std::string ARKTSInner_FormatJSError(ARKTS_Env env, ARKTS_Value jsError)
85 {
86     auto vm = P_CAST(env, EcmaVM*);
87     auto exception = BIT_CAST(jsError, Local<JSValueRef>);
88     if (exception->IsString(vm)) {
89         auto errorInsJs = *P_CAST(jsError, StringRef*);
90         return errorInsJs.ToString(vm);
91     } else if (exception->IsError(vm)) {
92         auto errorObJ = *P_CAST(jsError, ObjectRef*);
93         auto nameValue = errorObJ.Get(vm, StringRef::NewFromUtf8(vm, "name"));
94         auto messageValue = errorObJ.Get(vm, StringRef::NewFromUtf8(vm, "message"));
95         auto stackValue = errorObJ.Get(vm, StringRef::NewFromUtf8(vm, "stack"));
96         std::string name = nameValue->IsString(vm) ? nameValue->ToString(vm)->ToString(vm) : "";
97         auto message = messageValue->IsString(vm) ? messageValue->ToString(vm)->ToString(vm) : "";
98         auto stack = stackValue->IsString(vm) ? stackValue->ToString(vm)->ToString(vm) : "";
99         return name + "\n" + message + "\n" + stack;
100     } else {
101         return "[unknown js Error type]";
102     }
103 }
104 
ARKTS_GetGlobalConstant(ARKTS_Env env)105 ARKTS_Value ARKTS_GetGlobalConstant(ARKTS_Env env)
106 {
107     ARKTS_ASSERT_P(env, "env is null");
108     auto vm = P_CAST(env, EcmaVM*);
109     auto result = JSNApi::GetGlobalObject(vm);
110     return ARKTS_FromHandle(result);
111 }
112 
ARKTS_GetPosixThreadId()113 uint64_t ARKTS_GetPosixThreadId()
114 {
115     auto id = std::this_thread::get_id();
116     return *reinterpret_cast<uint64_t*>(&id);
117 }
118 
ARKTS_GetValueType(ARKTS_Env env,ARKTS_Value src)119 ARKTS_ValueType ARKTS_GetValueType(ARKTS_Env env, ARKTS_Value src)
120 {
121     ARKTS_ASSERT(src, "src is null", N_UNDEFINED);
122     auto value = BIT_CAST(src, JSValueRef);
123     if (value.IsHole()) {
124         return N_UNDEFINED;
125     } else if (value.IsNull()) {
126         return N_NULL;
127     } else if (value.IsUndefined()) {
128         return N_UNDEFINED;
129     } else if (value.IsBoolean()) {
130         return N_BOOL;
131     } else if (value.IsNumber()) {
132         return N_NUMBER;
133     }
134 
135     value = *P_CAST(src, JSValueRef*);
136     auto vm = P_CAST(env, EcmaVM*);
137     if (value.IsNull()) {
138         return N_NULL;
139     } else if (value.IsString(vm)) {
140         return N_STRING;
141     } else if (value.IsSymbol(vm)) {
142         return N_SYMBOL;
143     } else if (value.IsFunction(vm)) {
144         return N_FUNCTION;
145     } else if (value.IsBigInt(vm)) {
146         return N_BIGINT;
147     } else if (value.IsNativePointer(vm)) {
148         return N_EXTERNAL;
149     } else {
150         return N_OBJECT;
151     }
152 }
153 
ARKTS_StrictEqual(ARKTS_Env env,ARKTS_Value a,ARKTS_Value b)154 bool ARKTS_StrictEqual(ARKTS_Env env, ARKTS_Value a, ARKTS_Value b)
155 {
156     ARKTS_ASSERT_F(env, "env is NULL");
157     auto aType = ARKTS_GetValueType(env, a);
158     auto bType = ARKTS_GetValueType(env, b);
159     if (aType != bType) {
160         return false;
161     }
162     if (aType == N_UNDEFINED || aType == N_NULL) {
163         return true;
164     }
165     switch (aType) {
166         case N_BOOL: {
167             auto aRef = BIT_CAST(a, BooleanRef);
168             auto bRef = BIT_CAST(b, BooleanRef);
169 
170             return aRef.Value() == bRef.Value();
171         }
172         case N_NUMBER: {
173             auto aRef = BIT_CAST(a, JSValueRef);
174             auto bRef = BIT_CAST(b, JSValueRef);
175 
176             double aValue = aRef.IsInt() ? BIT_CAST(a, IntegerRef).Value() : BIT_CAST(a, NumberRef).Value();
177             double bValue = bRef.IsInt() ? BIT_CAST(b, IntegerRef).Value() : BIT_CAST(b, NumberRef).Value();
178 
179             return aValue == bValue;
180         }
181         default:
182             auto aTag = *P_CAST(a, JSValueRef*);
183             auto bTag = BIT_CAST(b, Local<JSValueRef>);
184             auto vm = P_CAST(env, EcmaVM*);
185             return aTag.IsStrictEquals(vm, bTag);
186     }
187 }
188 
ARKTS_CreateNull()189 ARKTS_Value ARKTS_CreateNull()
190 {
191     return P_CAST(JSTaggedValue::VALUE_NULL, ARKTS_Value);
192 }
193 
ARKTS_IsNull(ARKTS_Value value)194 bool ARKTS_IsNull(ARKTS_Value value)
195 {
196     return P_CAST(value, JSTaggedType) == JSTaggedValue::VALUE_NULL;
197 }
198 
ARKTS_CreateUndefined()199 ARKTS_Value ARKTS_CreateUndefined()
200 {
201     return P_CAST(JSTaggedValue::VALUE_UNDEFINED, ARKTS_Value);
202 }
203 
ARKTS_IsUndefined(ARKTS_Value value)204 bool ARKTS_IsUndefined(ARKTS_Value value)
205 {
206     return P_CAST(value, JSTaggedType) == JSTaggedValue::VALUE_UNDEFINED;
207 }
208 
ARKTS_CreateBool(bool value)209 ARKTS_Value ARKTS_CreateBool(bool value)
210 {
211     return P_CAST(value ? JSTaggedValue::VALUE_TRUE : JSTaggedValue::VALUE_FALSE, ARKTS_Value);
212 }
213 
ARKTS_IsBool(ARKTS_Value value)214 bool ARKTS_IsBool(ARKTS_Value value)
215 {
216     auto v = BIT_CAST(value, JSValueRef);
217     return v.IsBoolean();
218 }
219 
ARKTS_GetValueBool(ARKTS_Value value)220 bool ARKTS_GetValueBool(ARKTS_Value value)
221 {
222     auto tag = BIT_CAST(value, JSValueRef);
223     ARKTS_ASSERT_F(tag.IsBoolean(), "not a boolean");
224     auto boolRef = BIT_CAST(value, BooleanRef);
225     return boolRef.Value();
226 }
227 
ARKTS_CreateF64(double value)228 ARKTS_Value ARKTS_CreateF64(double value)
229 {
230     JSTaggedValue result(value);
231     return BIT_CAST(result, ARKTS_Value);
232 }
233 
ARKTS_CreateI32(int32_t value)234 EXPORT ARKTS_Value ARKTS_CreateI32(int32_t value)
235 {
236     JSTaggedValue result(value);
237     return BIT_CAST(result, ARKTS_Value);
238 }
239 
ARKTS_GetValueNumber(ARKTS_Value value)240 double ARKTS_GetValueNumber(ARKTS_Value value)
241 {
242     auto ref = BIT_CAST(value, JSValueRef);
243     ARKTS_ASSERT_I(ref.IsNumber(), "not a number");
244     if (ref.IsInt()) {
245         return BIT_CAST(value, IntegerRef).Value();
246     } else {
247         return BIT_CAST(value, NumberRef).Value();
248     }
249 }
250 
ARKTS_IsNumber(ARKTS_Value value)251 bool ARKTS_IsNumber(ARKTS_Value value)
252 {
253     auto jValue = BIT_CAST(value, JSValueRef);
254     return jValue.IsNumber();
255 }
256 
257 struct LambdaData {
258     ARKTS_Env env;
259     int64_t lambdaId;
260 };
261 
CJLambdaInvoker(JsiRuntimeCallInfo * callInfo)262 static Local<JSValueRef> CJLambdaInvoker(JsiRuntimeCallInfo* callInfo)
263 {
264     auto data = reinterpret_cast<LambdaData*>(callInfo->GetData());
265     if (!data) {
266         return JSValueRef::Undefined(callInfo->GetVM());
267     }
268     auto result = ARKTSInner_CJLambdaInvoker(P_CAST(callInfo, ARKTS_CallInfo), data->lambdaId);
269     return BIT_CAST(result, Local<JSValueRef>);
270 }
271 
CJLambdaDeleter(void *,void *,void * raw)272 static void CJLambdaDeleter(void* /* env: napi_env */, void* /*invoker*/, void* raw)
273 {
274     auto data = reinterpret_cast<LambdaData*>(raw);
275     if (!data) {
276         return;
277     }
278     ARKTSInner_CJLambdaDeleter(data->env, data->lambdaId);
279     delete data;
280 }
281 
ARKTS_CreateFunc(ARKTS_Env env,int64_t lambdaId)282 ARKTS_Value ARKTS_CreateFunc(ARKTS_Env env, int64_t lambdaId)
283 {
284     ARKTS_ASSERT_P(env, "env is null");
285 
286     auto vm = P_CAST(env, EcmaVM*);
287     auto result = FunctionRef::New(vm, CJLambdaInvoker, CJLambdaDeleter, new LambdaData {env, lambdaId}, true);
288 
289     return ARKTS_FromHandle(result);
290 }
291 
ARKTS_IsClass(ARKTS_Env env,ARKTS_Value value)292 bool ARKTS_IsClass(ARKTS_Env env, ARKTS_Value value)
293 {
294     auto tag = BIT_CAST(value, JSValueRef);
295     if (!tag.IsHeapObject()) {
296         return false;
297     }
298     auto vm = P_CAST(env, EcmaVM*);
299     tag = *P_CAST(value, JSValueRef*);
300     return tag.IsConstructor(vm);
301 }
302 
ARKTS_CreateClass(ARKTS_Env env,int64_t lambdaId,ARKTS_Value base)303 ARKTS_Value ARKTS_CreateClass(ARKTS_Env env, int64_t lambdaId, ARKTS_Value base)
304 {
305     ARKTS_ASSERT_P(env, "env is null");
306 
307     auto vm = P_CAST(env, EcmaVM*);
308 
309     auto result = FunctionRef::NewClassFunction(vm, CJLambdaInvoker, CJLambdaDeleter,
310                                                 new LambdaData {env, lambdaId}, true);
311 
312     if (ARKTS_IsClass(env, base)) {
313         auto baseClass = BIT_CAST(base, Local<FunctionRef>);
314         result->Inherit(vm, baseClass);
315     }
316 
317     return ARKTS_FromHandle(result);
318 }
319 
ARKTS_GetPrototype(ARKTS_Env env,ARKTS_Value value)320 ARKTS_Value ARKTS_GetPrototype(ARKTS_Env env, ARKTS_Value value)
321 {
322     ARKTS_ASSERT_P(env, "env is null");
323     ARKTS_ASSERT_P(ARKTS_IsClass(env, value), "value is not constructor");
324     auto vm = P_CAST(env, EcmaVM*);
325     auto clazz = BIT_CAST(value, Local<FunctionRef>);
326     auto result = clazz->GetFunctionPrototype(vm);
327     return ARKTS_FromHandle(result);
328 }
329 
ARKTS_InstanceOf(ARKTS_Env env,ARKTS_Value object,ARKTS_Value clazz)330 bool ARKTS_InstanceOf(ARKTS_Env env, ARKTS_Value object, ARKTS_Value clazz)
331 {
332     ARKTS_ASSERT_F(env, "env is null");
333     ARKTS_ASSERT_F(ARKTS_IsHeapObject(object), "object is not heap object");
334     ARKTS_ASSERT_F(ARKTS_IsClass(env, clazz), "clazz is not a class");
335 
336     auto vm = P_CAST(env, EcmaVM*);
337     auto targetObject = BIT_CAST(object, Local<JSValueRef>);
338     auto targetClass = BIT_CAST(clazz, Local<FunctionRef>);
339 
340     return targetObject->InstanceOf(vm, targetClass);
341 }
342 
ARKTS_IsCallable(ARKTS_Env env,ARKTS_Value value)343 bool ARKTS_IsCallable(ARKTS_Env env, ARKTS_Value value)
344 {
345     return ARKTS_GetValueType(env, value) == N_FUNCTION;
346 }
347 
348 static constexpr auto MAX_CALL_ARGS = 255;
349 
FormatArguments(int32_t numArgs,ARKTS_Value args[],Local<JSValueRef> * result)350 ARKTS_INLINE void FormatArguments(int32_t numArgs, ARKTS_Value args[], Local<JSValueRef>* result)
351 {
352     for (int32_t i = 0;i < numArgs; ++i) {
353         result[i] = ARKTS_ToHandle<JSValueRef>(args[i]);
354     }
355 }
356 
ARKTS_Call(ARKTS_Env env,ARKTS_Value func,ARKTS_Value thisArg,int32_t numArgs,ARKTS_Value args[])357 ARKTS_Value ARKTS_Call(ARKTS_Env env, ARKTS_Value func, ARKTS_Value thisArg, int32_t numArgs, ARKTS_Value args[])
358 {
359     ARKTS_ASSERT_P(env, "env is null");
360     ARKTS_ASSERT_P(ARKTS_IsCallable(env, func), "func is not callable");
361     ARKTS_ASSERT_P(numArgs <= MAX_CALL_ARGS, "too many arguments, 255 most");
362 
363     auto vm = P_CAST(env, EcmaVM*);
364 
365     auto funcHandle = *P_CAST(func, FunctionRef*);
366     auto thisHandle = ARKTS_ToHandle<JSValueRef>(thisArg);
367 
368     Local<JSValueRef> formattedArgs[MAX_CALL_ARGS];
369     FormatArguments(numArgs, args, formattedArgs);
370 
371     auto result = funcHandle.Call(vm, thisHandle, formattedArgs, numArgs);
372 
373     ARKTSInner_ReportJSErrors(env, true);
374 
375     return ARKTS_FromHandle(result);
376 }
377 
ARKTS_New(ARKTS_Env env,ARKTS_Value clazz,int32_t numArgs,ARKTS_Value args[])378 ARKTS_Value ARKTS_New(ARKTS_Env env, ARKTS_Value clazz, int32_t numArgs, ARKTS_Value args[])
379 {
380     ARKTS_ASSERT_P(env, "env is null");
381     ARKTS_ASSERT_P(ARKTS_IsClass(env, clazz), "clazz is not class");
382     ARKTS_ASSERT_P(numArgs <= MAX_CALL_ARGS, "too many arguments, 255 most");
383 
384     auto vm = P_CAST(env, EcmaVM*);
385     auto funcHandle = *P_CAST(clazz, FunctionRef*);
386 
387     Local<JSValueRef> formattedArgs[MAX_CALL_ARGS];
388     FormatArguments(numArgs, args, formattedArgs);
389 
390     auto result = funcHandle.Constructor(vm, formattedArgs, numArgs);
391 
392     ARKTSInner_ReportJSErrors(env, true);
393 
394     return ARKTS_FromHandle(result);
395 }
396 
397 // JSArray elements stored in vector mode and dict mode.
398 // default in vector mode,
399 // if capacity grows gap bigger than 1024, will transform to dict mode.
ARKTS_CreateArray(ARKTS_Env env,uint32_t size)400 ARKTS_Value ARKTS_CreateArray(ARKTS_Env env, uint32_t size)
401 {
402     ARKTS_ASSERT_P(env, "env is null");
403 
404     auto vm = P_CAST(env, EcmaVM*);
405     auto result = ArrayRef::New(vm, size);
406     return BIT_CAST(result, ARKTS_Value);
407 }
408 
ARKTS_CreateArrayWithInit(ARKTS_Env env,uint32_t size,ARKTS_Value * data)409 ARKTS_Value ARKTS_CreateArrayWithInit(ARKTS_Env env, uint32_t size, ARKTS_Value* data)
410 {
411     ARKTS_ASSERT_P(env, "env is null");
412     auto vm = P_CAST(env, EcmaVM*);
413 
414     auto result = ArrayRef::New(vm, size);
415     for (uint32_t i = 0;i < size; ++i) {
416         ArrayRef::SetValueAt(vm, result, i, ARKTS_ToHandle<JSValueRef>(data[i]));
417     }
418 
419     return BIT_CAST(result, ARKTS_Value);
420 }
421 
ARKTS_GetArrayLength(ARKTS_Env env,ARKTS_Value array)422 uint32_t ARKTS_GetArrayLength(ARKTS_Env env, ARKTS_Value array)
423 {
424     ARKTS_ASSERT_I(env, "env is null");
425     ARKTS_ASSERT_I(ARKTS_IsArray(env, array), "array is not array");
426 
427     auto vm = P_CAST(env, EcmaVM*);
428     auto jArr = *P_CAST(array, ArrayRef*);
429 
430     return jArr.Length(vm);
431 }
432 
ARKTS_SetElement(ARKTS_Env env,ARKTS_Value array,uint32_t index,ARKTS_Value value)433 void ARKTS_SetElement(ARKTS_Env env, ARKTS_Value array, uint32_t index, ARKTS_Value value)
434 {
435     ARKTS_ASSERT_V(env, "env is null");
436     ARKTS_ASSERT_V(ARKTS_IsArray(env, array), "array is not array");
437 
438     auto vm = P_CAST(env, EcmaVM*);
439     auto jArr = BIT_CAST(array, Local<ArrayRef>);
440 
441     ArrayRef::SetValueAt(vm, jArr, index, ARKTS_ToHandle<JSValueRef>(value));
442 }
443 
ARKTS_GetElement(ARKTS_Env env,ARKTS_Value array,uint32_t index)444 ARKTS_Value ARKTS_GetElement(ARKTS_Env env, ARKTS_Value array, uint32_t index)
445 {
446     ARKTS_ASSERT_P(env, "env is null");
447     ARKTS_ASSERT_P(ARKTS_IsArray(env, array), "array is not array");
448     auto vm = P_CAST(env, EcmaVM*);
449     auto arr = BIT_CAST(array, Local<ArrayRef>);
450     ARKTS_ASSERT_P(arr->Length(vm) > index, "out of index");
451 
452     auto result = ArrayRef::GetValueAt(vm, arr, index);
453 
454     return ARKTS_FromHandle(result);
455 }
456 
ARKTS_IsArray(ARKTS_Env env,ARKTS_Value value)457 bool ARKTS_IsArray(ARKTS_Env env, ARKTS_Value value)
458 {
459     ARKTS_ASSERT_F(env, "env is NULL");
460     auto v = BIT_CAST(value, JSValueRef);
461     if (!v.IsHeapObject()) {
462         return false;
463     }
464     v = *P_CAST(value, JSValueRef*);
465     auto vm = P_CAST(env, EcmaVM*);
466     return v.IsArray(vm);
467 }
468 
ARKTS_CreateArrayBuffer(ARKTS_Env env,int32_t length)469 ARKTS_Value ARKTS_CreateArrayBuffer(ARKTS_Env env, int32_t length)
470 {
471     ARKTS_ASSERT_P(env, "env is null");
472     auto vm = P_CAST(env, EcmaVM*);
473     auto result = ArrayBufferRef::New(vm, length);
474     return ARKTS_FromHandle(result);
475 }
476 
ARKTS_CreateArrayBufferWithData(ARKTS_Env env,void * buffer,int32_t length,int64_t finalizerHint)477 ARKTS_Value ARKTS_CreateArrayBufferWithData(ARKTS_Env env, void* buffer, int32_t length,
478     int64_t finalizerHint)
479 {
480     ARKTS_ASSERT_P(env, "env is null");
481 
482     auto vm = P_CAST(env, EcmaVM*);
483     auto result = ArrayBufferRef::New(vm, buffer, length, ARKTSInner_CJArrayBufferDeleter,
484                                       reinterpret_cast<void*>(finalizerHint));
485 
486     return ARKTS_FromHandle(result);
487 }
488 
ARKTS_IsArrayBuffer(ARKTS_Env env,ARKTS_Value value)489 bool ARKTS_IsArrayBuffer(ARKTS_Env env, ARKTS_Value value)
490 {
491     auto tag = BIT_CAST(value, JSValueRef);
492     if (!tag.IsHeapObject()) {
493         return false;
494     }
495     auto vm = P_CAST(env, EcmaVM*);
496     auto handle = BIT_CAST(value, Local<JSValueRef>);
497     return handle->IsArrayBuffer(vm) || handle->IsTypedArray(vm) || handle->IsDataView(vm);
498 }
499 
ARKTS_GetArrayBufferLength(ARKTS_Env env,ARKTS_Value value)500 int32_t ARKTS_GetArrayBufferLength(ARKTS_Env env, ARKTS_Value value)
501 {
502     ARKTS_ASSERT_I(env, "env is null");
503     ARKTS_ASSERT_I(ARKTS_IsArrayBuffer(env, value), "value is not arrayBuffer");
504 
505     auto vm = P_CAST(env, EcmaVM*);
506     auto handle = BIT_CAST(value, Local<JSValueRef>);
507     if (handle->IsArrayBuffer(vm)) {
508         return BIT_CAST(value, Local<ArrayBufferRef>)->ByteLength(vm);
509     } else if (handle->IsTypedArray(vm)) {
510         auto arr = BIT_CAST(value, Local<TypedArrayRef>);
511         return arr->ByteLength(vm) - arr->ByteOffset(vm);
512     } else {
513         auto arr = BIT_CAST(value, Local<DataViewRef>);
514         return arr->ByteLength() - arr->ByteOffset();
515     }
516 }
517 
ARKTS_GetArrayBufferRawPtr(ARKTS_Env env,ARKTS_Value value)518 void* ARKTS_GetArrayBufferRawPtr(ARKTS_Env env, ARKTS_Value value)
519 {
520     ARKTS_ASSERT_P(env, "env is null");
521     ARKTS_ASSERT_P(ARKTS_IsArrayBuffer(env, value), "value is not arrayBuffer");
522 
523     auto vm = P_CAST(env, EcmaVM*);
524     auto handle = BIT_CAST(value, Local<JSValueRef>);
525     if (handle->IsArrayBuffer(vm)) {
526         return BIT_CAST(value, Local<ArrayBufferRef>)->GetBuffer(vm);
527     } else if (handle->IsTypedArray(vm)) {
528         auto arr = BIT_CAST(value, Local<TypedArrayRef>);
529         auto rawStart = arr->GetArrayBuffer(vm)->GetBuffer(vm);
530         auto rawOffset = arr->ByteOffset(vm);
531         return P_CAST(rawStart, uint8_t*) + rawOffset;
532     } else {
533         auto arr = BIT_CAST(value, Local<DataViewRef>);
534         auto rawStart = arr->GetArrayBuffer(vm)->GetBuffer(vm);
535         auto rawOffset = arr->ByteOffset();
536         return P_CAST(rawStart, uint8_t*) + rawOffset;
537     }
538 }
539 
ARKTS_ArrayBufferReadBytes(ARKTS_Env env,ARKTS_Value buffer,void * dest,int32_t count)540 int32_t ARKTS_ArrayBufferReadBytes(ARKTS_Env env, ARKTS_Value buffer, void* dest, int32_t count)
541 {
542     auto src = ARKTS_GetArrayBufferRawPtr(env, buffer);
543     auto srcSize = ARKTS_GetArrayBufferLength(env, buffer);
544     auto targetSize = std::min(srcSize, count);
545     if (memcpy_s(dest, count, src, targetSize) != targetSize) {
546         LOGE("ARKTS_ArrayBufferReadBytes error, memcpy_s ret size incorrect");
547     }
548     return targetSize;
549 }
550 
ARKTS_CreateExternal(ARKTS_Env env,void * data)551 ARKTS_Value ARKTS_CreateExternal(ARKTS_Env env, void* data)
552 {
553     ARKTS_ASSERT_P(env, "env is null");
554 
555     auto vm = P_CAST(env, EcmaVM*);
556     auto result = NativePointerRef::New(vm, data, ARKTSInner_CJExternalDeleter, env);
557     return BIT_CAST(result, ARKTS_Value);
558 }
559 
ARKTS_IsExternal(ARKTS_Env env,ARKTS_Value value)560 bool ARKTS_IsExternal(ARKTS_Env env, ARKTS_Value value)
561 {
562     auto prime = BIT_CAST(value, JSValueRef);
563     if (!prime.IsHeapObject()) {
564         return false;
565     }
566     auto handle = BIT_CAST(value, JSValueRef*);
567     auto vm = P_CAST(env, EcmaVM*);
568     return handle->IsNativePointer(vm);
569 }
570 
ARKTS_GetExternalData(ARKTS_Env env,ARKTS_Value value)571 void* ARKTS_GetExternalData(ARKTS_Env env, ARKTS_Value value)
572 {
573     ARKTS_ASSERT_P(ARKTS_IsExternal(env, value), "value is not external data");
574     auto external = *P_CAST(value, NativePointerRef*);
575     return external.Value();
576 }
577 
ARKTS_CreatePromiseCapability(ARKTS_Env env)578 ARKTS_Promise ARKTS_CreatePromiseCapability(ARKTS_Env env)
579 {
580     ARKTS_ASSERT_P(env, "env is null");
581 
582     auto vm = P_CAST(env, EcmaVM*);
583 
584     auto promise = PromiseCapabilityRef::New(vm);
585     auto result = new Global<PromiseCapabilityRef>(vm, promise);
586 
587     return BIT_CAST(result, ARKTS_Promise);
588 }
589 
ARKTS_GetPromiseFromCapability(ARKTS_Env env,ARKTS_Promise prom)590 ARKTS_Value ARKTS_GetPromiseFromCapability(ARKTS_Env env, ARKTS_Promise prom)
591 {
592     ARKTS_ASSERT_P(env, "env is null");
593     ARKTS_ASSERT_P(prom, "prom is null");
594 
595     auto vm = P_CAST(env, EcmaVM*);
596     auto promise = *P_CAST(prom, Global<PromiseCapabilityRef>*);
597     auto result = (*promise)->GetPromise(vm);
598 
599     return BIT_CAST(result, ARKTS_Value);
600 }
601 
ARKTS_PromiseCapabilityResolve(ARKTS_Env env,ARKTS_Promise prom,ARKTS_Value result)602 void ARKTS_PromiseCapabilityResolve(ARKTS_Env env, ARKTS_Promise prom, ARKTS_Value result)
603 {
604     ARKTS_ASSERT_V(env, "env is null");
605     ARKTS_ASSERT_V(prom, "prom is null");
606 
607     auto vm = P_CAST(env, EcmaVM*);
608     auto promise = P_CAST(prom, Global<PromiseCapabilityRef>*);
609     (*promise)->Resolve(vm, ARKTS_ToHandle<JSValueRef>(result));
610     delete promise;
611 }
612 
ARKTS_PromiseCapabilityReject(ARKTS_Env env,ARKTS_Promise prom,ARKTS_Value result)613 void ARKTS_PromiseCapabilityReject(ARKTS_Env env, ARKTS_Promise prom, ARKTS_Value result)
614 {
615     ARKTS_ASSERT_V(env, "env is null");
616     ARKTS_ASSERT_V(prom, "prom is null");
617 
618     auto vm = P_CAST(env, EcmaVM*);
619     auto promise = P_CAST(prom, Global<PromiseCapabilityRef>*);
620     (*promise)->Reject(vm, ARKTS_ToHandle<JSValueRef>(result));
621     delete promise;
622 }
623 
ARKTS_IsPromise(ARKTS_Env env,ARKTS_Value value)624 bool ARKTS_IsPromise(ARKTS_Env env, ARKTS_Value value)
625 {
626     auto v = BIT_CAST(value, JSValueRef);
627     if (!v.IsHeapObject()) {
628         return false;
629     }
630     auto vm = P_CAST(env, EcmaVM*);
631     v= *P_CAST(value, JSValueRef*);
632     return v.IsPromise(vm);
633 }
634 
ARKTS_PromiseThen(ARKTS_Env env,ARKTS_Value prom,ARKTS_Value onFulfilled,ARKTS_Value onRejected)635 ARKTS_Value ARKTS_PromiseThen(ARKTS_Env env, ARKTS_Value prom, ARKTS_Value onFulfilled, ARKTS_Value onRejected)
636 {
637     ARKTS_ASSERT_P(env, "env is null");
638     ARKTS_ASSERT_P(ARKTS_IsPromise(env, prom), "arg is not a JSPromise");
639     ARKTS_ASSERT_P(ARKTS_IsCallable(env, onFulfilled), "onFulfilled is not callable");
640 
641     auto vm = P_CAST(env, EcmaVM*);
642     auto promise = *BIT_CAST(prom, PromiseRef*);
643     auto onFulfilledFunc = BIT_CAST(onFulfilled, Local<FunctionRef>);
644     auto onRejectTag = BIT_CAST(onRejected, Local<JSValueRef>);
645     Local<PromiseRef> result;
646     if (onRejectTag->IsFunction(vm)) {
647         auto onRejectedFunc = BIT_CAST(onRejected, Local<FunctionRef>);
648         result = promise.Then(vm, onFulfilledFunc, onRejectedFunc);
649     } else {
650         result = promise.Then(vm, onFulfilledFunc);
651     }
652     return ARKTS_FromHandle(result);
653 }
654 
ARKTS_PromiseCatch(ARKTS_Env env,ARKTS_Value prom,ARKTS_Value callback)655 void ARKTS_PromiseCatch(ARKTS_Env env, ARKTS_Value prom, ARKTS_Value callback)
656 {
657     ARKTS_ASSERT_V(env, "env is null");
658     ARKTS_ASSERT_V(ARKTS_IsPromise(env, prom), "arg is not a JSPromise");
659     ARKTS_ASSERT_V(ARKTS_IsCallable(env, callback), "callback is not callable");
660 
661     auto vm = P_CAST(env, EcmaVM*);
662     auto promise = BIT_CAST(prom, PromiseRef*);
663     auto callbackFunc = BIT_CAST(callback, Local<FunctionRef>);
664     promise->Catch(vm, callbackFunc);
665 }
666 
ARKTS_OpenScope(ARKTS_Env env)667 ARKTS_Scope ARKTS_OpenScope(ARKTS_Env env)
668 {
669     ARKTS_ASSERT_P(env, "env is null");
670     auto vm = P_CAST(env, EcmaVM*);
671     return CJ::ARKTS_ScopeManager::OpenScope(vm);
672 }
673 
ARKTS_Return(ARKTS_Env env,ARKTS_Scope scope,ARKTS_Value value)674 ARKTS_Result ARKTS_Return(ARKTS_Env env, ARKTS_Scope scope, ARKTS_Value value)
675 {
676     ARKTS_ASSERT_P(env, "env is null");
677     ARKTS_ASSERT_P(value, "value is invalid");
678 
679     auto vm = P_CAST(env, EcmaVM*);
680     if (!CJ::ARKTS_ScopeManager::CloseScope(scope)) {
681         ARKTSInner_ReportNativeError("exit scope of unknown");
682     }
683 
684     return ARKTS_ToResult(vm, value);
685 }
686 
ARKTS_CloseScope(ARKTS_Env env,ARKTS_Scope scope)687 void ARKTS_CloseScope(ARKTS_Env env, ARKTS_Scope scope)
688 {
689     ARKTS_ASSERT_V(env, "env is null");
690     ARKTS_ASSERT_V(scope, "scope is invalid");
691 
692     if (!CJ::ARKTS_ScopeManager::CloseScope(scope)) {
693         ARKTSInner_ReportNativeError("exit scope of unknown");
694     }
695 }
696 
ARKTSInner_Escape(ARKTS_Env env,ARKTS_Scope scope,ARKTS_Value ret)697 panda::JSValueRef* ARKTSInner_Escape(ARKTS_Env env, ARKTS_Scope scope, ARKTS_Value ret)
698 {
699     if (!CJ::ARKTS_ScopeManager::CloseScope(scope)) {
700         ARKTSInner_ReportNativeError("exit scope of unknown");
701     }
702 
703     auto vm = P_CAST(env, EcmaVM*);
704     auto value = ARKTS_ToValue(ret);
705 
706     auto result = JSNApi::CreateLocal(vm, value);
707 
708     return BIT_CAST(result, JSValueRef*);
709 }
710 
ARKTS_Throw(ARKTS_Env env,ARKTS_Value error)711 void ARKTS_Throw(ARKTS_Env env, ARKTS_Value error)
712 {
713     ARKTS_ASSERT_V(env, "env is null");
714     auto vm = P_CAST(env, EcmaVM*);
715 
716     if (JSNApi::HasPendingException(vm)) {
717         LOGE("ARKTS_Throw failed, vm has uncaught exception");
718         return;
719     }
720 
721     auto exception = ARKTS_ToHandle<JSValueRef>(error);
722     if (exception->IsString(vm)) {
723         JSNApi::ThrowException(vm, Exception::Error(vm, BIT_CAST(exception, Local<StringRef>)));
724     } else {
725         JSNApi::ThrowException(vm, exception);
726     }
727 }
728 
ARKTS_GetCallEnv(ARKTS_CallInfo info)729 ARKTS_Env ARKTS_GetCallEnv(ARKTS_CallInfo info)
730 {
731     ARKTS_ASSERT_I(info, "info is null");
732     auto runInfo = P_CAST(info, JsiRuntimeCallInfo*);
733     auto vm = runInfo->GetVM();
734     return P_CAST(vm, ARKTS_Env);
735 }
736 
ARKTS_GetArgCount(ARKTS_CallInfo info)737 uint32_t ARKTS_GetArgCount(ARKTS_CallInfo info)
738 {
739     ARKTS_ASSERT_I(info, "info is null");
740     auto runInfo = P_CAST(info, JsiRuntimeCallInfo*);
741     return runInfo->GetArgsNumber();
742 }
743 
ARKTS_GetArg(ARKTS_CallInfo info,uint32_t index)744 ARKTS_Value ARKTS_GetArg(ARKTS_CallInfo info, uint32_t index)
745 {
746     ARKTS_ASSERT_P(info, "info is null");
747     auto runInfo = P_CAST(info, JsiRuntimeCallInfo*);
748     ARKTS_ASSERT_P(runInfo->GetArgsNumber() > index, "out of index");
749     auto result = runInfo->GetCallArgRef(index);
750     return ARKTS_FromHandle(result);
751 }
752 
ARKTS_GetThisArg(ARKTS_CallInfo info)753 ARKTS_Value ARKTS_GetThisArg(ARKTS_CallInfo info)
754 {
755     ARKTS_ASSERT_P(info, "info is null");
756     auto runInfo = P_CAST(info, JsiRuntimeCallInfo*);
757     auto result = runInfo->GetThisRef();
758     return ARKTS_FromHandle(result);
759 }
760 
ARKTS_GetGlobalNapiEnv(ARKTS_Env env)761 void* ARKTS_GetGlobalNapiEnv(ARKTS_Env env)
762 {
763     ARKTS_ASSERT_P(env, "env is null");
764     auto vm = P_CAST(env, EcmaVM*);
765     return JSNApi::GetEnv(vm);
766 }
767