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