1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <cstring> 17 #include <vector> 18 19 #include "commonlibrary/ets_utils/js_util_module/util/js_base64.h" 20 #include "commonlibrary/ets_utils/js_util_module/util/js_textdecoder.h" 21 #include "commonlibrary/ets_utils/js_util_module/util/js_textencoder.h" 22 #include "commonlibrary/ets_utils/js_util_module/util/js_types.h" 23 #include "commonlibrary/ets_utils/js_util_module/util/js_uuid.h" 24 #include "commonlibrary/ets_utils/js_util_module/util/js_stringdecoder.h" 25 26 #include "securec.h" 27 #include "tools/log.h" 28 29 #include "napi/native_api.h" 30 #include "napi/native_node_api.h" 31 #include "native_engine.h" 32 #include "jni_helper.h" 33 34 extern const char _binary_util_js_js_start[]; 35 extern const char _binary_util_js_js_end[]; 36 extern const char _binary_util_abc_start[]; 37 extern const char _binary_util_abc_end[]; 38 static const std::vector<std::string> conventFormat = {"utf-8", "UTF-8", "gbk", "GBK", "GB2312", "gb2312", 39 "GB18030", "gb18030", "ibm866", "iso-8859-2", "iso-8859-3", 40 "iso-8859-4", "iso-8859-5", "iso-8859-6", "iso-8859-7", 41 "iso-8859-8", "iso-8859-8-i", "iso-8859-10", "iso-8859-13", 42 "iso-8859-14", "iso-8859-15", "koi8-r", "koi8-u", "macintosh", 43 "windows-874", "windows-1250", "windows-1251", "windows-1252", 44 "windows-1253", "windows-1254", "windows-1255", "windows-1256", 45 "windows-1257", "windows-1258", "big5", "euc-jp", "iso-2022-jp", 46 "shift_jis", "euc-kr", "x-mac-cyrillic", "utf-16be", 47 "utf-16le", "iso-8859-1"}; 48 49 namespace OHOS::Util { 50 using namespace Commonlibrary::Platform; IsValidValue(napi_env env,napi_value value)51 static bool IsValidValue(napi_env env, napi_value value) 52 { 53 napi_value undefinedRef = nullptr; 54 napi_value nullRef = nullptr; 55 napi_get_undefined(env, &undefinedRef); 56 napi_get_null(env, &nullRef); 57 bool isUndefined = false; 58 bool isNull = false; 59 napi_strict_equals(env, value, undefinedRef, &isUndefined); 60 napi_strict_equals(env, value, nullRef, &isNull); 61 return !(isUndefined || isNull); 62 } 63 ApplyMemory(const size_t length)64 static char* ApplyMemory(const size_t length) 65 { 66 if (length == 0) { 67 return nullptr; 68 } 69 char *type = new (std::nothrow) char[length + 1]; 70 if (type == nullptr) { 71 HILOG_ERROR("type is nullptr"); 72 return nullptr; 73 } 74 if (memset_s(type, length + 1, '\0', length + 1) != EOK) { 75 HILOG_ERROR("type memset_s failed"); 76 delete[] type; 77 return nullptr; 78 } 79 return type; 80 } 81 82 static std::string temp = "cdfijoOs"; DealWithPrintf(const std::string & format,const std::vector<std::string> & value)83 static std::string DealWithPrintf(const std::string &format, const std::vector<std::string> &value) 84 { 85 size_t i = 0; 86 size_t j = 0; 87 std::string str; 88 size_t formatSize = format.size(); 89 size_t valueSize = value.size(); 90 while (i < formatSize && j < valueSize) { 91 if (format[i] == '%' && (i + 1 < formatSize && format[i + 1] == '%')) { 92 str += '%'; 93 i += 2; // 2:The array goes back two digits. 94 } else if (format[i] == '%' && (i + 1 < formatSize && (temp.find(format[i + 1])) != std::string::npos)) { 95 if (format[i + 1] == 'c') { 96 j++; 97 } else { 98 str += value[j++]; 99 } 100 i += 2; // 2:The array goes back two digits. 101 } else if (format[i] == '%' && (i + 1 < formatSize && (temp.find(format[i + 1])) == std::string::npos)) { 102 str += '%'; 103 i++; 104 } 105 if (i < formatSize && format[i] != '%') { 106 size_t pos = 0; 107 if ((pos = format.find('%', i)) == std::string::npos) { 108 str += format.substr(i); 109 i = formatSize; 110 break; 111 } else { 112 str += format.substr(i, pos - i); 113 i = pos; 114 } 115 } 116 } 117 while (j < valueSize) { 118 str += " " + value[j++]; 119 } 120 if (i < formatSize) { 121 str += format.substr(i); 122 } 123 return str; 124 } 125 ThrowError(napi_env env,const char * errMessage)126 static napi_value ThrowError(napi_env env, const char* errMessage) 127 { 128 napi_value utilError = nullptr; 129 napi_value code = nullptr; 130 uint32_t errCode = 401; 131 napi_create_uint32(env, errCode, &code); 132 napi_value name = nullptr; 133 std::string errName = "BusinessError"; 134 napi_value msg = nullptr; 135 napi_create_string_utf8(env, errMessage, NAPI_AUTO_LENGTH, &msg); 136 napi_create_string_utf8(env, errName.c_str(), NAPI_AUTO_LENGTH, &name); 137 napi_create_error(env, nullptr, msg, &utilError); 138 napi_set_named_property(env, utilError, "code", code); 139 napi_set_named_property(env, utilError, "name", name); 140 napi_throw(env, utilError); 141 return nullptr; 142 } 143 FormatString(napi_env env,std::string & str)144 static napi_value FormatString(napi_env env, std::string &str) 145 { 146 std::string res; 147 size_t strSize = str.size(); 148 for (size_t i = 0; i < strSize; ++i) { 149 if (str[i] == '%' && (i + 1 < strSize && temp.find(str[i + 1]) != std::string::npos)) { 150 if (str[i + 1] == 'o') { 151 res += "o "; 152 } else if (str[i + 1] == 'O') { 153 res += "O "; 154 } else if (str[i + 1] == 'i') { 155 res += "i "; 156 } else if (str[i + 1] == 'j') { 157 res += "j "; 158 } else if (str[i + 1] == 'd') { 159 res += "d "; 160 } else if (str[i + 1] == 's') { 161 res += "s "; 162 } else if (str[i + 1] == 'f') { 163 res += "f "; 164 } else if (str[i + 1] == 'c') { 165 res += "c "; 166 } 167 i++; 168 } else if (str[i] == '%' && (i + 1 < strSize && str[i + 1] == '%')) { 169 i++; 170 } 171 } 172 if (!res.empty()) { 173 res = res.substr(0, res.size() - 1); 174 } 175 napi_value result = nullptr; 176 napi_create_string_utf8(env, res.c_str(), res.size(), &result); 177 return result; 178 } 179 FreeMemory(napi_value * address)180 static void FreeMemory(napi_value *address) 181 { 182 delete[] address; 183 address = nullptr; 184 } 185 DealWithFormatString(napi_env env,napi_callback_info info)186 static napi_value DealWithFormatString(napi_env env, napi_callback_info info) 187 { 188 size_t argc = 1; 189 napi_value argv = nullptr; 190 napi_get_cb_info(env, info, &argc, 0, nullptr, nullptr); 191 192 napi_get_cb_info(env, info, &argc, &argv, nullptr, nullptr); 193 std::string format = ""; 194 size_t formatsize = 0; 195 if (napi_get_value_string_utf8(env, argv, nullptr, 0, &formatsize) != napi_ok) { 196 HILOG_ERROR("can not get argv size"); 197 return nullptr; 198 } 199 format.reserve(formatsize + 1); 200 format.resize(formatsize); 201 if (napi_get_value_string_utf8(env, argv, format.data(), formatsize + 1, &formatsize) != napi_ok) { 202 HILOG_ERROR("can not get argv value"); 203 return nullptr; 204 } 205 return FormatString(env, format); 206 } 207 PrintfString(const std::string & format,const std::vector<std::string> & value)208 static std::string PrintfString(const std::string &format, const std::vector<std::string> &value) 209 { 210 return DealWithPrintf(format, value); 211 } 212 Printf(napi_env env,napi_callback_info info)213 static napi_value Printf(napi_env env, napi_callback_info info) 214 { 215 napi_value result = nullptr; 216 size_t argc = 0; 217 napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); 218 napi_value *argv = nullptr; 219 if (argc > 0) { 220 argv = new (std::nothrow) napi_value[argc]; 221 if (argv == nullptr) { 222 HILOG_ERROR("Printf:: argv is nullptr"); 223 return nullptr; 224 } 225 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 226 std::string format = ""; 227 size_t formatsize = 0; 228 if (napi_get_value_string_utf8(env, argv[0], nullptr, 0, &formatsize) != napi_ok) { 229 HILOG_ERROR("can not get argv[0] size"); 230 FreeMemory(argv); 231 return nullptr; 232 } 233 format.reserve(formatsize); 234 format.resize(formatsize); 235 if (napi_get_value_string_utf8(env, argv[0], format.data(), formatsize + 1, &formatsize) != napi_ok) { 236 HILOG_ERROR("can not get argv[0] value"); 237 FreeMemory(argv); 238 return nullptr; 239 } 240 std::vector<std::string> value; 241 for (size_t i = 1; i < argc; i++) { 242 std::string valueString = ""; 243 size_t valuesize = 0; 244 if (napi_get_value_string_utf8(env, argv[i], nullptr, 0, &valuesize) != napi_ok) { 245 HILOG_ERROR("can not get argv[i] size"); 246 FreeMemory(argv); 247 return nullptr; 248 } 249 valueString.reserve(valuesize); 250 valueString.resize(valuesize); 251 if (napi_get_value_string_utf8(env, argv[i], valueString.data(), 252 valuesize + 1, &valuesize) != napi_ok) { 253 HILOG_ERROR("can not get argv[i] value"); 254 FreeMemory(argv); 255 return nullptr; 256 } 257 value.push_back(valueString.data()); 258 } 259 std::string printInfo = PrintfString(format.data(), value); 260 napi_create_string_utf8(env, printInfo.c_str(), printInfo.size(), &result); 261 FreeMemory(argv); 262 return result; 263 } 264 napi_value res = nullptr; 265 NAPI_CALL(env, napi_get_undefined(env, &res)); 266 return res; 267 } 268 GetErrorString(napi_env env,napi_callback_info info)269 static napi_value GetErrorString(napi_env env, napi_callback_info info) 270 { 271 napi_value thisVar = nullptr; 272 napi_value result = nullptr; 273 std::string errInfo; 274 size_t argc = 1; 275 napi_value argv = nullptr; 276 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 277 int32_t err = 0; 278 NAPI_CALL(env, napi_get_value_int32(env, argv, &err)); 279 errInfo = uv_strerror(err); 280 NAPI_CALL(env, napi_create_string_utf8(env, errInfo.c_str(), errInfo.size(), &result)); 281 return result; 282 } 283 RandomUUID(napi_env env,napi_callback_info info)284 static napi_value RandomUUID(napi_env env, napi_callback_info info) 285 { 286 napi_value thisVar = nullptr; 287 size_t requireArgc = 1; 288 size_t argc = 1; 289 napi_value args[1] = { 0 }; 290 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 291 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 292 bool flag = false; 293 napi_get_value_bool(env, args[0], &flag); 294 std::string uuidString = OHOS::Util::GetStringUUID(env, flag); 295 napi_value result = nullptr; 296 size_t tempLen = uuidString.size(); 297 napi_create_string_utf8(env, uuidString.c_str(), tempLen, &result); 298 return result; 299 } 300 RandomBinaryUUID(napi_env env,napi_callback_info info)301 static napi_value RandomBinaryUUID(napi_env env, napi_callback_info info) 302 { 303 napi_value thisVar = nullptr; 304 size_t requireArgc = 1; 305 size_t argc = 1; 306 napi_value args[1] = { 0 }; 307 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 308 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 309 bool flag = false; 310 napi_get_value_bool(env, args[0], &flag); 311 napi_value result = OHOS::Util::GetBinaryUUID(env, flag); 312 return result; 313 } 314 ParseUUID(napi_env env,napi_callback_info info)315 static napi_value ParseUUID(napi_env env, napi_callback_info info) 316 { 317 napi_value thisVar = nullptr; 318 size_t requireArgc = 1; 319 size_t argc = 1; 320 napi_value args[1] = { nullptr }; 321 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 322 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 323 napi_valuetype valuetype; 324 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype)); 325 NAPI_ASSERT(env, valuetype == napi_string, "Wrong argument type. String expected."); 326 napi_value result = OHOS::Util::DoParseUUID(env, args[0]); 327 return result; 328 } 329 GetHash(napi_env env,napi_callback_info info)330 static napi_value GetHash(napi_env env, napi_callback_info info) 331 { 332 napi_value thisVar = nullptr; 333 size_t requireArgc = 1; 334 size_t argc = 1; 335 napi_value args[1] = { nullptr }; 336 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 337 if (argc < requireArgc) { 338 napi_throw_error(env, "-1", "Expected 1 parameter, actually not included in the parameter."); 339 return nullptr; 340 } 341 napi_valuetype valuetype; 342 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype)); 343 if (valuetype != napi_object) { 344 return ThrowError(env, "Parameter error. The type of Parameter must be object."); 345 } 346 NativeEngine *engine = reinterpret_cast<NativeEngine*>(env); 347 int32_t value = engine->GetObjectHash(env, args[0]); 348 napi_value result = nullptr; 349 napi_create_uint32(env, value, &result); 350 return result; 351 } 352 SetVec(const napi_status fatSta,const napi_status bomSta,const bool fat,const bool bom,std::vector<int> & paraVec)353 static void SetVec(const napi_status fatSta, const napi_status bomSta, const bool fat, const bool bom, 354 std::vector<int> ¶Vec) 355 { 356 if (paraVec.size() != 2) { // 2:The number of parameters is 2 357 return; 358 } 359 if (fatSta == napi_ok) { 360 if (fat) { 361 paraVec[0] = 1; 362 } else { 363 paraVec[0] = 0; 364 } 365 } 366 if (bomSta == napi_ok) { 367 if (bom) { 368 paraVec[1] = 1; 369 } else { 370 paraVec[1] = 0; 371 } 372 } 373 } 374 GetSecPara(napi_env env,napi_value valData,std::vector<int> & paraVec)375 static napi_value GetSecPara(napi_env env, napi_value valData, std::vector<int> ¶Vec) 376 { 377 napi_value messageKeyFatal = nullptr; 378 const char *messageKeyStrFatal = "fatal"; 379 napi_value messageKeyIgnorebom = nullptr; 380 const char *messageKeyStrIgnorebom = "ignoreBOM"; 381 napi_value resultFatal = nullptr; 382 napi_value resultIgnorebom = nullptr; 383 bool bResultFat = false; 384 bool bResultIgnbom = false; 385 NAPI_CALL(env, napi_create_string_utf8(env, messageKeyStrFatal, strlen(messageKeyStrFatal), 386 &messageKeyFatal)); 387 NAPI_CALL(env, napi_create_string_utf8(env, messageKeyStrIgnorebom, strlen(messageKeyStrIgnorebom), 388 &messageKeyIgnorebom)); 389 NAPI_CALL(env, napi_get_property(env, valData, messageKeyFatal, &resultFatal)); 390 NAPI_CALL(env, napi_get_property(env, valData, messageKeyIgnorebom, &resultIgnorebom)); 391 napi_status naFat = napi_get_value_bool(env, resultFatal, &bResultFat); 392 napi_status naBom = napi_get_value_bool(env, resultIgnorebom, &bResultIgnbom); 393 SetVec(naFat, naBom, bResultFat, bResultIgnbom, paraVec); 394 return nullptr; 395 } 396 TextdecoderConstructor(napi_env env,napi_callback_info info)397 static napi_value TextdecoderConstructor(napi_env env, napi_callback_info info) 398 { 399 size_t tempArgc = 0; 400 napi_value thisVar = nullptr; 401 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 402 size_t argc = 0; 403 void *data = nullptr; 404 char *type = nullptr; 405 size_t typeLen = 0; 406 std::vector<int> paraVec(2, 0); // 2: Specifies the size of the container to be applied for. 407 if (tempArgc == 1) { 408 argc = 1; 409 napi_value argv = nullptr; 410 napi_get_cb_info(env, info, &argc, &argv, nullptr, &data); 411 napi_get_value_string_utf8(env, argv, nullptr, 0, &typeLen); 412 if (typeLen > 0) { 413 type = ApplyMemory(typeLen); 414 } 415 napi_get_value_string_utf8(env, argv, type, typeLen + 1, &typeLen); 416 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 417 argc = 2; // 2: The number of parameters is 2. 418 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 419 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &data); 420 // first para 421 napi_get_value_string_utf8(env, argvArr[0], nullptr, 0, &typeLen); 422 if (typeLen > 0) { 423 type = ApplyMemory(typeLen); 424 } 425 napi_get_value_string_utf8(env, argvArr[0], type, typeLen + 1, &typeLen); 426 napi_valuetype valueType1; 427 napi_typeof(env, argvArr[1], &valueType1); 428 if (valueType1 != napi_undefined && valueType1 != napi_null) { 429 // second para 430 GetSecPara(env, argvArr[1], paraVec); 431 } 432 } 433 std::string enconding = "utf-8"; 434 if (type != nullptr) { 435 enconding = type; 436 } 437 delete []type; 438 type = nullptr; 439 auto objectInfo = new (std::nothrow) TextDecoder(enconding, paraVec); 440 if (objectInfo == nullptr) { 441 HILOG_ERROR("TextDecoder objectInfo is nullptr"); 442 return nullptr; 443 } 444 NAPI_CALL(env, napi_wrap( 445 env, thisVar, objectInfo, 446 [](napi_env environment, void *data, void *hint) { 447 auto objInfo = reinterpret_cast<TextDecoder*>(data); 448 if (objInfo != nullptr) { 449 delete objInfo; 450 objInfo = nullptr; 451 } 452 }, 453 nullptr, nullptr)); 454 return thisVar; 455 } 456 DecodeToString(napi_env env,napi_callback_info info)457 static napi_value DecodeToString(napi_env env, napi_callback_info info) 458 { 459 size_t tempArgc = 2; // 2:The number of parameters is 2 460 napi_value thisVar = nullptr; 461 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 462 size_t argc = 0; 463 void *dataPara = nullptr; 464 napi_typedarray_type type; 465 size_t length = 0; 466 void *data = nullptr; 467 napi_value arraybuffer = nullptr; 468 size_t byteOffset = 0; 469 bool iStream = false; 470 TextDecoder *textDecoder = nullptr; 471 napi_unwrap(env, thisVar, (void**)&textDecoder); 472 if (textDecoder == nullptr) { 473 HILOG_ERROR("DecodeToString::textDecoder is nullptr"); 474 return nullptr; 475 } 476 napi_value valStr = nullptr; 477 if (tempArgc == 1) { 478 argc = 1; 479 napi_value argv = nullptr; 480 napi_get_cb_info(env, info, &argc, &argv, nullptr, &dataPara); 481 napi_get_typedarray_info(env, argv, &type, &length, &data, &arraybuffer, &byteOffset); 482 if (type != napi_uint8_array) { 483 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 484 } 485 valStr = textDecoder->DecodeToString(env, argv, iStream); 486 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 487 argc = 2; // 2: The number of parameters is 2. 488 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 489 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &dataPara); 490 napi_get_typedarray_info(env, argvArr[0], &type, &length, &data, &arraybuffer, &byteOffset); 491 if (type != napi_uint8_array) { 492 return ThrowError(env, "Parameter error. The type of first Parameter must be Uint8Array."); 493 } 494 napi_valuetype valueType; 495 napi_typeof(env, argvArr[1], &valueType); 496 if (valueType != napi_undefined && valueType != napi_null) { 497 if (valueType != napi_object) { 498 return ThrowError(env, "Parameter error. The type of second Parameter must be object."); 499 } 500 const char *messageKeyStrStream = "stream"; 501 napi_value resultStream = nullptr; 502 napi_get_named_property(env, argvArr[1], messageKeyStrStream, &resultStream); 503 napi_get_value_bool(env, resultStream, &iStream); 504 } 505 valStr = textDecoder->DecodeToString(env, argvArr[0], iStream); 506 } 507 return valStr; 508 } 509 TextdecoderDecode(napi_env env,napi_callback_info info)510 static napi_value TextdecoderDecode(napi_env env, napi_callback_info info) 511 { 512 size_t tempArgc = 2; // 2:The number of parameters is 2 513 napi_value thisVar = nullptr; 514 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 515 size_t argc = 0; 516 void *dataPara = nullptr; 517 napi_typedarray_type type; 518 size_t length = 0; 519 void *data = nullptr; 520 napi_value arraybuffer = nullptr; 521 size_t byteOffset = 0; 522 bool iStream = false; 523 TextDecoder *textDecoder = nullptr; 524 napi_unwrap(env, thisVar, (void**)&textDecoder); 525 if (textDecoder == nullptr) { 526 return nullptr; 527 } 528 napi_value valStr = nullptr; 529 if (tempArgc == 1) { 530 argc = 1; 531 napi_value argv = nullptr; 532 napi_get_cb_info(env, info, &argc, &argv, nullptr, &dataPara); 533 // first para 534 napi_get_typedarray_info(env, argv, &type, &length, &data, &arraybuffer, &byteOffset); 535 if (type != napi_uint8_array) { 536 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 537 } 538 valStr = textDecoder->Decode(env, argv, iStream); 539 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 540 argc = 2; // 2: The number of parameters is 2. 541 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 542 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &dataPara); 543 // first para 544 napi_get_typedarray_info(env, argvArr[0], &type, &length, &data, &arraybuffer, &byteOffset); 545 // second para 546 if (type != napi_uint8_array) { 547 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 548 } 549 napi_valuetype valueType1; 550 napi_typeof(env, argvArr[1], &valueType1); 551 if (valueType1 != napi_undefined && valueType1 != napi_null) { 552 if (valueType1 != napi_object) { 553 return ThrowError(env, "Parameter error. The type of Parameter must be object."); 554 } 555 napi_value messageKeyStream = nullptr; 556 const char *messageKeyStrStream = "stream"; 557 558 napi_value resultStream = nullptr; 559 NAPI_CALL(env, napi_create_string_utf8(env, messageKeyStrStream, strlen(messageKeyStrStream), 560 &messageKeyStream)); 561 NAPI_CALL(env, napi_get_property(env, argvArr[1], messageKeyStream, &resultStream)); 562 NAPI_CALL(env, napi_get_value_bool(env, resultStream, &iStream)); 563 } 564 valStr = textDecoder->Decode(env, argvArr[0], iStream); 565 } 566 return valStr; 567 } 568 TextdecoderGetEncoding(napi_env env,napi_callback_info info)569 static napi_value TextdecoderGetEncoding(napi_env env, napi_callback_info info) 570 { 571 napi_value thisVar = nullptr; 572 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); 573 TextDecoder *textDecoder = nullptr; 574 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&textDecoder)); 575 napi_value retVal = textDecoder->GetEncoding(env); 576 return retVal; 577 } 578 TextdecoderGetFatal(napi_env env,napi_callback_info info)579 static napi_value TextdecoderGetFatal(napi_env env, napi_callback_info info) 580 { 581 napi_value thisVar = nullptr; 582 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); 583 TextDecoder *textDecoder = nullptr; 584 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&textDecoder)); 585 napi_value retVal = textDecoder->GetFatal(env); 586 return retVal; 587 } 588 TextdecoderGetIgnoreBOM(napi_env env,napi_callback_info info)589 static napi_value TextdecoderGetIgnoreBOM(napi_env env, napi_callback_info info) 590 { 591 napi_value thisVar = nullptr; 592 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); 593 TextDecoder *textDecoder = nullptr; 594 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&textDecoder)); 595 napi_value retVal = textDecoder->GetIgnoreBOM(env); 596 return retVal; 597 } 598 CheckEncodingFormat(const std::string & encoding)599 static bool CheckEncodingFormat(const std::string &encoding) 600 { 601 for (const auto& format : conventFormat) { 602 if (format == encoding) { 603 return true; 604 } 605 } 606 return false; 607 } 608 InitTextEncoder(napi_env env,napi_value thisVar,std::string encoding,std::string orgEncoding)609 static napi_value InitTextEncoder(napi_env env, napi_value thisVar, std::string encoding, std::string orgEncoding) 610 { 611 auto object = new (std::nothrow) TextEncoder(encoding); 612 if (object == nullptr) { 613 HILOG_ERROR("TextEncoder:: memory allocation failed, object is nullptr"); 614 return nullptr; 615 } 616 object->SetOrgEncoding(orgEncoding); 617 napi_status status = napi_wrap(env, thisVar, object, 618 [](napi_env environment, void *data, void *hint) { 619 auto obj = reinterpret_cast<TextEncoder*>(data); 620 if (obj != nullptr) { 621 delete obj; 622 obj = nullptr; 623 } 624 }, nullptr, nullptr); 625 if (status != napi_ok) { 626 delete object; 627 object = nullptr; 628 } 629 return thisVar; 630 } 631 632 // Encoder TextEncoderConstructor(napi_env env,napi_callback_info info)633 static napi_value TextEncoderConstructor(napi_env env, napi_callback_info info) 634 { 635 size_t argc = 0; 636 napi_value thisVar = nullptr; 637 napi_value src = nullptr; 638 napi_get_cb_info(env, info, &argc, &src, &thisVar, nullptr); 639 std::string encoding = "utf-8"; 640 std::string orgEncoding = encoding; 641 if (argc == 1) { 642 napi_get_cb_info(env, info, &argc, &src, nullptr, nullptr); 643 napi_valuetype valuetype; 644 napi_typeof(env, src, &valuetype); 645 if (valuetype != napi_undefined && valuetype != napi_null) { 646 if (valuetype != napi_string) { 647 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 648 } 649 size_t bufferSize = 0; 650 if (napi_get_value_string_utf8(env, src, nullptr, 0, &bufferSize) != napi_ok) { 651 HILOG_ERROR("can not get src size"); 652 return nullptr; 653 } 654 std::string buffer(bufferSize, '\0'); 655 if (napi_get_value_string_utf8(env, src, buffer.data(), bufferSize + 1, &bufferSize) != napi_ok) { 656 HILOG_ERROR("can not get src value"); 657 return nullptr; 658 } 659 orgEncoding = buffer; 660 for (char &temp : buffer) { 661 temp = std::tolower(static_cast<unsigned char>(temp)); 662 } 663 NAPI_ASSERT(env, CheckEncodingFormat(buffer), 664 "Wrong encoding format, the current encoding format is not support"); 665 encoding = buffer; 666 } 667 } 668 return InitTextEncoder(env, thisVar, encoding, orgEncoding); 669 } 670 GetEncoding(napi_env env,napi_callback_info info)671 static napi_value GetEncoding(napi_env env, napi_callback_info info) 672 { 673 napi_value thisVar = nullptr; 674 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); 675 676 TextEncoder *object = nullptr; 677 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 678 679 return object->GetEncoding(env); 680 } 681 Encode(napi_env env,napi_callback_info info)682 static napi_value Encode(napi_env env, napi_callback_info info) 683 { 684 napi_value thisVar = nullptr; 685 size_t requireArgc = 1; 686 size_t argc = 1; 687 napi_value args = nullptr; 688 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 689 NAPI_ASSERT(env, argc <= requireArgc, "Wrong number of arguments"); 690 691 napi_value result; 692 if (argc == 1) { 693 napi_valuetype valuetype; 694 NAPI_CALL(env, napi_typeof(env, args, &valuetype)); 695 if (!IsValidValue(env, args)) { 696 napi_get_undefined(env, &result); 697 return result; 698 } 699 NAPI_ASSERT(env, valuetype == napi_string, "Wrong argument type. String expected."); 700 } else { 701 napi_get_undefined(env, &result); 702 return result; 703 } 704 TextEncoder *object = nullptr; 705 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 706 707 result = object->Encode(env, args); 708 709 return result; 710 } 711 EncodeIntoOne(napi_env env,napi_callback_info info)712 static napi_value EncodeIntoOne(napi_env env, napi_callback_info info) 713 { 714 napi_value thisVar = nullptr; 715 size_t argc = 1; 716 napi_value args = nullptr; 717 napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr); 718 napi_value result; 719 if (argc == 1) { 720 napi_valuetype valuetype; 721 NAPI_CALL(env, napi_typeof(env, args, &valuetype)); 722 if (!IsValidValue(env, args)) { 723 napi_get_undefined(env, &result); 724 return result; 725 } 726 if (valuetype != napi_string) { 727 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 728 } 729 } else { 730 napi_get_undefined(env, &result); 731 return result; 732 } 733 TextEncoder *object = nullptr; 734 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 735 result = object->Encode(env, args); 736 return result; 737 } 738 EncodeIntoTwo(napi_env env,napi_callback_info info)739 static napi_value EncodeIntoTwo(napi_env env, napi_callback_info info) 740 { 741 napi_value thisVar = nullptr; 742 size_t requireArgc = 2; // 2:The number of parameters is 2 743 size_t argc = 2; // 2:The number of parameters is 2 744 napi_value args[2] = { nullptr }; // 2:The number of parameters is 2 745 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 746 747 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 748 749 napi_valuetype valuetype0; 750 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); 751 752 napi_typedarray_type valuetype1; 753 size_t length = 0; 754 void *data = nullptr; 755 napi_value arraybuffer = nullptr; 756 size_t byteOffset = 0; 757 NAPI_CALL(env, napi_get_typedarray_info(env, args[1], &valuetype1, &length, &data, &arraybuffer, &byteOffset)); 758 759 NAPI_ASSERT(env, valuetype0 == napi_string, "Wrong argument type. String expected."); 760 NAPI_ASSERT(env, valuetype1 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 761 762 TextEncoder *object = nullptr; 763 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 764 765 napi_value result = object->EncodeInto(env, args[0], args[1]); 766 767 return result; 768 } 769 EncodeIntoUint8Array(napi_env env,napi_callback_info info)770 static napi_value EncodeIntoUint8Array(napi_env env, napi_callback_info info) 771 { 772 napi_value thisVar = nullptr; 773 size_t argc = 2; // 2:The number of parameters is 2 774 napi_value args[2] = { nullptr }; // 2:The number of parameters is 2 775 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 776 napi_valuetype valuetype0; 777 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); 778 napi_typedarray_type valuetype1; 779 size_t length = 0; 780 void *data = nullptr; 781 napi_value arraybuffer = nullptr; 782 size_t byteOffset = 0; 783 napi_get_typedarray_info(env, args[1], &valuetype1, &length, &data, &arraybuffer, &byteOffset); 784 if (valuetype0 != napi_string) { 785 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 786 } 787 if (valuetype1 != napi_uint8_array) { 788 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 789 } 790 TextEncoder *object = nullptr; 791 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 792 napi_value result = object->EncodeInto(env, args[0], args[1]); 793 return result; 794 } 795 EncodeIntoArgs(napi_env env,napi_callback_info info)796 static napi_value EncodeIntoArgs(napi_env env, napi_callback_info info) 797 { 798 napi_value thisVar = nullptr; 799 size_t argc = 0; 800 napi_value args[2] = { nullptr }; // 2:The number of parameters is 2 801 napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr); 802 if (argc >= 2) { // 2:The number of parameters is 2 803 return EncodeIntoTwo(env, info); 804 } 805 return EncodeIntoOne(env, info); 806 } 807 Create(napi_env env,napi_callback_info info)808 static napi_value Create(napi_env env, napi_callback_info info) 809 { 810 napi_value textEncoderObj = TextEncoderConstructor(env, info); 811 napi_property_descriptor textEncoderDesc[] = { 812 DECLARE_NAPI_GETTER("encoding", GetEncoding), 813 DECLARE_NAPI_FUNCTION("encode", Encode), 814 DECLARE_NAPI_FUNCTION("encodeInto", EncodeIntoArgs), 815 DECLARE_NAPI_FUNCTION("encodeIntoUint8Array", EncodeIntoUint8Array), 816 }; 817 napi_define_properties(env, textEncoderObj, sizeof(textEncoderDesc) / sizeof(textEncoderDesc[0]), 818 textEncoderDesc); 819 return textEncoderObj; 820 } 821 TextcoderInit(napi_env env,napi_value exports)822 static napi_value TextcoderInit(napi_env env, napi_value exports) 823 { 824 const char *textEncoderClassName = "TextEncoder"; 825 napi_value textEncoderClass = nullptr; 826 napi_property_descriptor textEncoderDesc[] = { 827 DECLARE_NAPI_GETTER("encoding", GetEncoding), 828 DECLARE_NAPI_FUNCTION("encode", Encode), 829 DECLARE_NAPI_FUNCTION("encodeInto", EncodeIntoArgs), 830 DECLARE_NAPI_FUNCTION("encodeIntoUint8Array", EncodeIntoUint8Array), 831 DECLARE_NAPI_STATIC_FUNCTION("create", Create), 832 833 }; 834 NAPI_CALL(env, napi_define_class(env, textEncoderClassName, strlen(textEncoderClassName), 835 TextEncoderConstructor, nullptr, 836 sizeof(textEncoderDesc) / sizeof(textEncoderDesc[0]), 837 textEncoderDesc, &textEncoderClass)); 838 839 const char *textDecoderClassName = "TextDecoder"; 840 napi_value textDecoderClass = nullptr; 841 napi_property_descriptor textdecoderDesc[] = { 842 DECLARE_NAPI_FUNCTION("decodeToString", DecodeToString), 843 DECLARE_NAPI_FUNCTION("decode", TextdecoderDecode), 844 DECLARE_NAPI_FUNCTION("decodeWithStream", TextdecoderDecode), 845 DECLARE_NAPI_GETTER("encoding", TextdecoderGetEncoding), 846 DECLARE_NAPI_GETTER("fatal", TextdecoderGetFatal), 847 DECLARE_NAPI_GETTER("ignoreBOM", TextdecoderGetIgnoreBOM), 848 }; 849 NAPI_CALL(env, napi_define_class(env, textDecoderClassName, strlen(textDecoderClassName), 850 TextdecoderConstructor, nullptr, 851 sizeof(textdecoderDesc) / sizeof(textdecoderDesc[0]), 852 textdecoderDesc, &textDecoderClass)); 853 napi_property_descriptor desc[] = { 854 DECLARE_NAPI_PROPERTY("TextEncoder", textEncoderClass), 855 DECLARE_NAPI_PROPERTY("TextDecoder", textDecoderClass), 856 }; 857 858 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 859 860 napi_value global = nullptr; 861 NAPI_CALL(env, napi_get_global(env, &global)); 862 NAPI_CALL(env, napi_set_named_property(env, global, "TextDecoderCreate_", textDecoderClass)); 863 864 return exports; 865 } 866 Base64Constructor(napi_env env,napi_callback_info info)867 static napi_value Base64Constructor(napi_env env, napi_callback_info info) 868 { 869 napi_value thisVar = nullptr; 870 void *data = nullptr; 871 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data)); 872 auto objectInfo = new Base64(); 873 napi_status status = napi_wrap(env, thisVar, objectInfo, 874 [](napi_env environment, void *data, void *hint) { 875 auto objInfo = reinterpret_cast<Base64*>(data); 876 if (objInfo != nullptr) { 877 delete objInfo; 878 objInfo = nullptr; 879 } 880 }, nullptr, nullptr); 881 if (status != napi_ok && objectInfo != nullptr) { 882 HILOG_ERROR("Base64Constructor:: napi_wrap failed"); 883 delete objectInfo; 884 objectInfo = nullptr; 885 } 886 return thisVar; 887 } 888 EncodeBase64(napi_env env,napi_callback_info info)889 static napi_value EncodeBase64(napi_env env, napi_callback_info info) 890 { 891 napi_value thisVar = nullptr; 892 size_t requireArgc = 1; 893 size_t argc = 1; 894 napi_value args[1] = { nullptr }; 895 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 896 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 897 napi_typedarray_type valuetype0; 898 size_t length = 0; 899 void *data = nullptr; 900 napi_value arraybuffer = nullptr; 901 size_t byteOffset = 0; 902 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 903 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 904 Base64 *object = nullptr; 905 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 906 napi_value result = object->EncodeSync(env, args[0], Type::BASIC); 907 return result; 908 } 909 EncodeToString(napi_env env,napi_callback_info info)910 static napi_value EncodeToString(napi_env env, napi_callback_info info) 911 { 912 napi_value thisVar = nullptr; 913 size_t requireArgc = 1; 914 size_t argc = 1; 915 napi_value args[1] = { nullptr }; 916 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 917 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 918 napi_typedarray_type valuetype0; 919 size_t length = 0; 920 void *data = nullptr; 921 napi_value arraybuffer = nullptr; 922 size_t byteOffset = 0; 923 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 924 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 925 Base64 *object = nullptr; 926 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 927 napi_value result = object->EncodeToStringSync(env, args[0], Type::BASIC); 928 return result; 929 } 930 DecodeBase64(napi_env env,napi_callback_info info)931 static napi_value DecodeBase64(napi_env env, napi_callback_info info) 932 { 933 napi_value thisVar = nullptr; 934 size_t requireArgc = 1; 935 size_t argc = 1; 936 napi_value args[1] = { nullptr }; 937 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 938 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 939 napi_typedarray_type valuetype0; 940 napi_valuetype valuetype1; 941 size_t length = 0; 942 void *data = nullptr; 943 napi_value arraybuffer = nullptr; 944 size_t byteOffset = 0; 945 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype1)); 946 if (valuetype1 != napi_valuetype::napi_string) { 947 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, 948 &data, &arraybuffer, &byteOffset)); 949 } 950 if ((valuetype1 != napi_valuetype::napi_string) && (valuetype0 != napi_typedarray_type::napi_uint8_array)) { 951 napi_throw_error(env, nullptr, "The parameter type is incorrect"); 952 return nullptr; 953 } 954 Base64 *object = nullptr; 955 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 956 napi_value result = object->DecodeSync(env, args[0], Type::BASIC); 957 return result; 958 } 959 EncodeAsync(napi_env env,napi_callback_info info)960 static napi_value EncodeAsync(napi_env env, napi_callback_info info) 961 { 962 napi_value thisVar = nullptr; 963 size_t requireArgc = 1; 964 size_t argc = 1; 965 napi_value args[1] = { nullptr }; 966 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 967 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 968 napi_typedarray_type valuetype0; 969 size_t length = 0; 970 void *data = nullptr; 971 napi_value arraybuffer = nullptr; 972 size_t byteOffset = 0; 973 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 974 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 975 Base64 *object = nullptr; 976 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 977 napi_value result = object->Encode(env, args[0], Type::BASIC); 978 return result; 979 } 980 EncodeToStringAsync(napi_env env,napi_callback_info info)981 static napi_value EncodeToStringAsync(napi_env env, napi_callback_info info) 982 { 983 napi_value thisVar = nullptr; 984 size_t requireArgc = 1; 985 size_t argc = 1; 986 napi_value args[1] = { nullptr }; 987 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 988 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 989 napi_typedarray_type valuetype0; 990 size_t length = 0; 991 void *data = nullptr; 992 napi_value arraybuffer = nullptr; 993 size_t byteOffset = 0; 994 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 995 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 996 Base64 *object = nullptr; 997 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 998 napi_value result = object->EncodeToString(env, args[0], Type::BASIC); 999 return result; 1000 } DecodeAsync(napi_env env,napi_callback_info info)1001 static napi_value DecodeAsync(napi_env env, napi_callback_info info) 1002 { 1003 napi_value thisVar = nullptr; 1004 size_t requireArgc = 1; 1005 size_t argc = 1; 1006 napi_value args[1] = { nullptr }; 1007 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1008 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1009 napi_typedarray_type valuetype0; 1010 napi_valuetype valuetype1; 1011 size_t length = 0; 1012 void *data = nullptr; 1013 napi_value arraybuffer = nullptr; 1014 size_t byteOffset = 0; 1015 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype1)); 1016 if (valuetype1 != napi_valuetype::napi_string) { 1017 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, 1018 &length, &data, &arraybuffer, &byteOffset)); 1019 } 1020 if ((valuetype1 != napi_valuetype::napi_string) && (valuetype0 != napi_typedarray_type::napi_uint8_array)) { 1021 napi_throw_error(env, nullptr, "The parameter type is incorrect"); 1022 return nullptr; 1023 } 1024 Base64 *object = nullptr; 1025 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1026 napi_value result = object->Decode(env, args[0], Type::BASIC); 1027 return result; 1028 } 1029 EncodeToStringHelper(napi_env env,napi_callback_info info)1030 static napi_value EncodeToStringHelper(napi_env env, napi_callback_info info) 1031 { 1032 size_t argc = 2; // 2:The number of parameters is 2 1033 napi_value args[2] = { nullptr }; 1034 napi_value thisVar = nullptr; 1035 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1036 int32_t encode = 0; 1037 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1038 Type typeValue = static_cast<Type>(encode); 1039 if (typeValue < Type::TYPED_FIRST || typeValue > Type::TYPED_LAST) { 1040 return ThrowError(env, 1041 "Parameter error. The target encoding type option must be one of the Type enumerations."); 1042 } 1043 Base64 *object = nullptr; 1044 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1045 return object->EncodeToStringSync(env, args[0], typeValue); 1046 } 1047 EncodeBase64Helper(napi_env env,napi_callback_info info)1048 static napi_value EncodeBase64Helper(napi_env env, napi_callback_info info) 1049 { 1050 size_t argc = 2; // 2:The number of parameters is 2 1051 napi_value args[2] = { nullptr }; 1052 napi_value thisVar = nullptr; 1053 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1054 int32_t encode = 0; 1055 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1056 Type typeValue = static_cast<Type>(encode); 1057 if (typeValue != Type::BASIC && typeValue != Type::BASIC_URL_SAFE) { 1058 return ThrowError(env, "Parameter error. The target encoding type option must be BASIC or BASIC_URL_SAFE."); 1059 } 1060 Base64 *object = nullptr; 1061 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1062 return object->EncodeSync(env, args[0], typeValue); 1063 } 1064 EncodeAsyncHelper(napi_env env,napi_callback_info info)1065 static napi_value EncodeAsyncHelper(napi_env env, napi_callback_info info) 1066 { 1067 size_t argc = 2; // 2:The number of parameters is 2 1068 napi_value args[2] = { nullptr }; 1069 napi_value thisVar = nullptr; 1070 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1071 int32_t encode = 0; 1072 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1073 Type typeValue = static_cast<Type>(encode); 1074 Base64 *object = nullptr; 1075 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1076 return object->Encode(env, args[0], typeValue); 1077 } 1078 EncodeToStringAsyncHelper(napi_env env,napi_callback_info info)1079 static napi_value EncodeToStringAsyncHelper(napi_env env, napi_callback_info info) 1080 { 1081 size_t argc = 2; // 2:The number of parameters is 2 1082 napi_value args[2] = { nullptr }; 1083 napi_value thisVar = nullptr; 1084 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1085 int32_t encode = 0; 1086 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1087 Type typeValue = static_cast<Type>(encode); 1088 Base64 *object = nullptr; 1089 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1090 napi_value result = object->EncodeToString(env, args[0], typeValue); 1091 return result; 1092 } 1093 DecodeBase64Helper(napi_env env,napi_callback_info info)1094 static napi_value DecodeBase64Helper(napi_env env, napi_callback_info info) 1095 { 1096 size_t argc = 2; // 2:The number of parameters is 2 1097 napi_value args[2] = { nullptr }; 1098 napi_value thisVar = nullptr; 1099 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1100 int32_t encode = 0; 1101 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1102 Type typeValue = static_cast<Type>(encode); 1103 if (typeValue < Type::TYPED_FIRST || typeValue > Type::TYPED_LAST) { 1104 return ThrowError(env, 1105 "Parameter error. The target encoding type option must be one of the Type enumerations."); 1106 } 1107 Base64 *object = nullptr; 1108 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1109 return object->DecodeSync(env, args[0], typeValue); 1110 } 1111 DecodeAsyncHelper(napi_env env,napi_callback_info info)1112 static napi_value DecodeAsyncHelper(napi_env env, napi_callback_info info) 1113 { 1114 size_t argc = 2; // 2:The number of parameters is 2 1115 napi_value args[2] = { nullptr }; 1116 napi_value thisVar = nullptr; 1117 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1118 int32_t encode = 0; 1119 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1120 Type typeValue = static_cast<Type>(encode); 1121 Base64 *object = nullptr; 1122 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1123 return object->Decode(env, args[0], typeValue); 1124 } 1125 1126 // Types TypesConstructor(napi_env env,napi_callback_info info)1127 static napi_value TypesConstructor(napi_env env, napi_callback_info info) 1128 { 1129 napi_value thisVar = nullptr; 1130 void* data = nullptr; 1131 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data)); 1132 auto objectInfo = new Types(); 1133 napi_status status = napi_wrap(env, thisVar, objectInfo, 1134 [](napi_env environment, void* data, void* hint) { 1135 auto objectInformation = reinterpret_cast<Types*>(data); 1136 if (objectInformation != nullptr) { 1137 delete objectInformation; 1138 objectInformation = nullptr; 1139 } 1140 }, nullptr, nullptr); 1141 if (status != napi_ok && objectInfo != nullptr) { 1142 delete objectInfo; 1143 objectInfo = nullptr; 1144 } 1145 return thisVar; 1146 } 1147 IsAnyArrayBuffer(napi_env env,napi_callback_info info)1148 static napi_value IsAnyArrayBuffer(napi_env env, napi_callback_info info) 1149 { 1150 napi_value thisVar = nullptr; 1151 size_t argc = 1; 1152 napi_value args = nullptr; 1153 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1154 Types* object = nullptr; 1155 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1156 napi_value rst = object->IsAnyArrayBuffer(env, args); 1157 return rst; 1158 } 1159 IsArrayBufferView(napi_env env,napi_callback_info info)1160 static napi_value IsArrayBufferView(napi_env env, napi_callback_info info) 1161 { 1162 napi_value thisVar = nullptr; 1163 size_t argc = 1; 1164 napi_value args = nullptr; 1165 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1166 Types* object = nullptr; 1167 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1168 napi_value rst = object->IsArrayBufferView(env, args); 1169 return rst; 1170 } 1171 IsArgumentsObject(napi_env env,napi_callback_info info)1172 static napi_value IsArgumentsObject(napi_env env, napi_callback_info info) 1173 { 1174 napi_value thisVar = nullptr; 1175 size_t argc = 1; 1176 napi_value args = nullptr; 1177 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1178 Types* object = nullptr; 1179 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1180 napi_value rst = object->IsArgumentsObject(env, args); 1181 return rst; 1182 } 1183 IsArrayBuffer(napi_env env,napi_callback_info info)1184 static napi_value IsArrayBuffer(napi_env env, napi_callback_info info) 1185 { 1186 napi_value thisVar = nullptr; 1187 size_t argc = 1; 1188 napi_value args = nullptr; 1189 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1190 Types* object = nullptr; 1191 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1192 napi_value rst = object->IsArrayBuffer(env, args); 1193 return rst; 1194 } 1195 IsAsyncFunction(napi_env env,napi_callback_info info)1196 static napi_value IsAsyncFunction(napi_env env, napi_callback_info info) 1197 { 1198 napi_value thisVar = nullptr; 1199 size_t argc = 1; 1200 napi_value args = nullptr; 1201 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1202 Types* object = nullptr; 1203 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1204 napi_value rst = object->IsAsyncFunction(env, args); 1205 return rst; 1206 } 1207 IsBigInt64Array(napi_env env,napi_callback_info info)1208 static napi_value IsBigInt64Array(napi_env env, napi_callback_info info) 1209 { 1210 napi_value thisVar = nullptr; 1211 size_t argc = 1; 1212 napi_value args = nullptr; 1213 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1214 Types* object = nullptr; 1215 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1216 napi_value rst = object->IsBigInt64Array(env, args); 1217 return rst; 1218 } 1219 IsBigUint64Array(napi_env env,napi_callback_info info)1220 static napi_value IsBigUint64Array(napi_env env, napi_callback_info info) 1221 { 1222 napi_value thisVar = nullptr; 1223 size_t argc = 1; 1224 napi_value args = nullptr; 1225 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1226 Types* object = nullptr; 1227 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1228 napi_value rst = object->IsBigUint64Array(env, args); 1229 return rst; 1230 } 1231 IsBooleanObject(napi_env env,napi_callback_info info)1232 static napi_value IsBooleanObject(napi_env env, napi_callback_info info) 1233 { 1234 napi_value thisVar = nullptr; 1235 size_t argc = 1; 1236 napi_value args = nullptr; 1237 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1238 Types* object = nullptr; 1239 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1240 napi_value rst = object->IsBooleanObject(env, args); 1241 return rst; 1242 } 1243 IsBoxedPrimitive(napi_env env,napi_callback_info info)1244 static napi_value IsBoxedPrimitive(napi_env env, napi_callback_info info) 1245 { 1246 napi_value thisVar = nullptr; 1247 size_t argc = 1; 1248 napi_value args = nullptr; 1249 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1250 Types* object = nullptr; 1251 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1252 napi_value rst = object->IsBoxedPrimitive(env, args); 1253 return rst; 1254 } 1255 IsDataView(napi_env env,napi_callback_info info)1256 static napi_value IsDataView(napi_env env, napi_callback_info info) 1257 { 1258 napi_value thisVar = nullptr; 1259 size_t argc = 1; 1260 napi_value args = nullptr; 1261 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1262 Types* object = nullptr; 1263 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1264 napi_value rst = object->IsDataView(env, args); 1265 return rst; 1266 } 1267 IsDate(napi_env env,napi_callback_info info)1268 static napi_value IsDate(napi_env env, napi_callback_info info) 1269 { 1270 napi_value thisVar = nullptr; 1271 size_t argc = 1; 1272 napi_value args = nullptr; 1273 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1274 Types* object = nullptr; 1275 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1276 napi_value rst = object->IsDate(env, args); 1277 return rst; 1278 } 1279 IsExternal(napi_env env,napi_callback_info info)1280 static napi_value IsExternal(napi_env env, napi_callback_info info) 1281 { 1282 napi_value thisVar = nullptr; 1283 size_t argc = 1; 1284 napi_value args = nullptr; 1285 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1286 Types* object = nullptr; 1287 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1288 napi_value rst = object->IsExternal(env, args); 1289 return rst; 1290 } 1291 IsFloat32Array(napi_env env,napi_callback_info info)1292 static napi_value IsFloat32Array(napi_env env, napi_callback_info info) 1293 { 1294 napi_value thisVar = nullptr; 1295 size_t argc = 1; 1296 napi_value args = nullptr; 1297 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1298 Types* object = nullptr; 1299 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1300 napi_value rst = object->IsFloat32Array(env, args); 1301 return rst; 1302 } 1303 IsFloat64Array(napi_env env,napi_callback_info info)1304 static napi_value IsFloat64Array(napi_env env, napi_callback_info info) 1305 { 1306 napi_value thisVar = nullptr; 1307 size_t argc = 1; 1308 napi_value args = nullptr; 1309 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1310 Types* object = nullptr; 1311 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1312 napi_value rst = object->IsFloat64Array(env, args); 1313 return rst; 1314 } 1315 IsGeneratorFunction(napi_env env,napi_callback_info info)1316 static napi_value IsGeneratorFunction(napi_env env, napi_callback_info info) 1317 { 1318 napi_value thisVar = nullptr; 1319 size_t argc = 1; 1320 napi_value args = nullptr; 1321 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1322 Types* object = nullptr; 1323 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1324 napi_value rst = object->IsGeneratorFunction(env, args); 1325 return rst; 1326 } 1327 IsGeneratorObject(napi_env env,napi_callback_info info)1328 static napi_value IsGeneratorObject(napi_env env, napi_callback_info info) 1329 { 1330 napi_value thisVar = nullptr; 1331 size_t requireArgc = 1; 1332 size_t argc = 1; 1333 napi_value args = nullptr; 1334 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1335 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1336 Types* object = nullptr; 1337 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1338 napi_value result = object->IsGeneratorObject(env, args); 1339 return result; 1340 } 1341 IsInt8Array(napi_env env,napi_callback_info info)1342 static napi_value IsInt8Array(napi_env env, napi_callback_info info) 1343 { 1344 napi_value thisVar = nullptr; 1345 size_t requireArgc = 1; 1346 size_t argc = 1; 1347 napi_value args = nullptr; 1348 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1349 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1350 Types* object = nullptr; 1351 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1352 napi_value result = object->IsInt8Array(env, args); 1353 return result; 1354 } 1355 IsInt16Array(napi_env env,napi_callback_info info)1356 static napi_value IsInt16Array(napi_env env, napi_callback_info info) 1357 { 1358 napi_value thisVar = nullptr; 1359 size_t requireArgc = 1; 1360 size_t argc = 1; 1361 napi_value args = nullptr; 1362 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1363 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1364 Types* object = nullptr; 1365 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1366 napi_value result = object->IsInt16Array(env, args); 1367 return result; 1368 } 1369 IsInt32Array(napi_env env,napi_callback_info info)1370 static napi_value IsInt32Array(napi_env env, napi_callback_info info) 1371 { 1372 napi_value thisVar = nullptr; 1373 size_t requireArgc = 1; 1374 size_t argc = 1; 1375 napi_value args = nullptr; 1376 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1377 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1378 Types* object = nullptr; 1379 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1380 napi_value result = object->IsInt32Array(env, args); 1381 return result; 1382 } 1383 IsMap(napi_env env,napi_callback_info info)1384 static napi_value IsMap(napi_env env, napi_callback_info info) 1385 { 1386 napi_value thisVar = nullptr; 1387 size_t requireArgc = 1; 1388 size_t argc = 1; 1389 napi_value args = nullptr; 1390 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1391 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1392 Types* object = nullptr; 1393 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1394 napi_value result = object->IsMap(env, args); 1395 return result; 1396 } 1397 IsMapIterator(napi_env env,napi_callback_info info)1398 static napi_value IsMapIterator(napi_env env, napi_callback_info info) 1399 { 1400 napi_value thisVar = nullptr; 1401 size_t requireArgc = 1; 1402 size_t argc = 1; 1403 napi_value args = nullptr; 1404 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1405 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1406 Types* object = nullptr; 1407 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1408 napi_value result = object->IsMapIterator(env, args); 1409 return result; 1410 } 1411 IsModuleNamespaceObject(napi_env env,napi_callback_info info)1412 static napi_value IsModuleNamespaceObject(napi_env env, napi_callback_info info) 1413 { 1414 napi_value thisVar = nullptr; 1415 size_t requireArgc = 1; 1416 size_t argc = 1; 1417 napi_value args = nullptr; 1418 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1419 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1420 Types* object = nullptr; 1421 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1422 napi_value result = object->IsModuleNamespaceObject(env, args); 1423 return result; 1424 } 1425 IsNativeError(napi_env env,napi_callback_info info)1426 static napi_value IsNativeError(napi_env env, napi_callback_info info) 1427 { 1428 napi_value thisVar = nullptr; 1429 size_t requireArgc = 1; 1430 size_t argc = 1; 1431 napi_value args = nullptr; 1432 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1433 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1434 Types* object = nullptr; 1435 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1436 napi_value result = object->IsNativeError(env, args); 1437 return result; 1438 } 1439 IsNumberObject(napi_env env,napi_callback_info info)1440 static napi_value IsNumberObject(napi_env env, napi_callback_info info) 1441 { 1442 napi_value thisVar = nullptr; 1443 size_t requireArgc = 1; 1444 size_t argc = 1; 1445 napi_value args = nullptr; 1446 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1447 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1448 Types* object = nullptr; 1449 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1450 napi_value result = object->IsNumberObject(env, args); 1451 return result; 1452 } 1453 IsPromise(napi_env env,napi_callback_info info)1454 static napi_value IsPromise(napi_env env, napi_callback_info info) 1455 { 1456 napi_value thisVar = nullptr; 1457 size_t requireArgc = 1; 1458 size_t argc = 1; 1459 napi_value args = nullptr; 1460 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1461 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1462 Types* object = nullptr; 1463 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1464 napi_value result = object->IsPromise(env, args); 1465 return result; 1466 } 1467 IsProxy(napi_env env,napi_callback_info info)1468 static napi_value IsProxy(napi_env env, napi_callback_info info) 1469 { 1470 napi_value thisVar = nullptr; 1471 size_t requireArgc = 1; 1472 size_t argc = 1; 1473 napi_value args = nullptr; 1474 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1475 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1476 Types* object = nullptr; 1477 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1478 napi_value result = object->IsProxy(env, args); 1479 return result; 1480 } 1481 IsRegExp(napi_env env,napi_callback_info info)1482 static napi_value IsRegExp(napi_env env, napi_callback_info info) 1483 { 1484 napi_value thisVar = nullptr; 1485 size_t requireArgc = 1; 1486 size_t argc = 1; 1487 napi_value args = nullptr; 1488 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1489 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1490 Types* object = nullptr; 1491 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1492 napi_value result = object->IsRegExp(env, args); 1493 return result; 1494 } 1495 IsSet(napi_env env,napi_callback_info info)1496 static napi_value IsSet(napi_env env, napi_callback_info info) 1497 { 1498 napi_value thisVar = nullptr; 1499 size_t requireArgc = 1; 1500 size_t argc = 1; 1501 napi_value args = nullptr; 1502 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1503 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1504 Types* object = nullptr; 1505 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1506 napi_value result = object->IsSet(env, args); 1507 return result; 1508 } 1509 IsSetIterator(napi_env env,napi_callback_info info)1510 static napi_value IsSetIterator(napi_env env, napi_callback_info info) 1511 { 1512 napi_value thisVar = nullptr; 1513 size_t requireArgc = 1; 1514 size_t argc = 1; 1515 napi_value args = nullptr; 1516 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1517 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1518 Types* object = nullptr; 1519 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1520 napi_value result = object->IsSetIterator(env, args); 1521 return result; 1522 } 1523 IsSharedArrayBuffer(napi_env env,napi_callback_info info)1524 static napi_value IsSharedArrayBuffer(napi_env env, napi_callback_info info) 1525 { 1526 napi_value thisVar = nullptr; 1527 size_t requireArgc = 1; 1528 size_t argc = 1; 1529 napi_value args = nullptr; 1530 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1531 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1532 Types* object = nullptr; 1533 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1534 napi_value result = object->IsSharedArrayBuffer(env, args); 1535 return result; 1536 } 1537 IsStringObject(napi_env env,napi_callback_info info)1538 static napi_value IsStringObject(napi_env env, napi_callback_info info) 1539 { 1540 napi_value thisVar = nullptr; 1541 size_t requireArgc = 1; 1542 size_t argc = 1; 1543 napi_value args = nullptr; 1544 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1545 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1546 Types* object = nullptr; 1547 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1548 napi_value result = object->IsStringObject(env, args); 1549 return result; 1550 } 1551 IsSymbolObject(napi_env env,napi_callback_info info)1552 static napi_value IsSymbolObject(napi_env env, napi_callback_info info) 1553 { 1554 napi_value thisVar = nullptr; 1555 size_t requireArgc = 1; 1556 size_t argc = 1; 1557 napi_value args = nullptr; 1558 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1559 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1560 Types* object = nullptr; 1561 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1562 napi_value result = object->IsSymbolObject(env, args); 1563 return result; 1564 } 1565 IsTypedArray(napi_env env,napi_callback_info info)1566 static napi_value IsTypedArray(napi_env env, napi_callback_info info) 1567 { 1568 napi_value thisVar = nullptr; 1569 size_t requireArgc = 1; 1570 size_t argc = 1; 1571 napi_value args = nullptr; 1572 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1573 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1574 Types* object = nullptr; 1575 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1576 napi_value result = object->IsTypedArray(env, args); 1577 return result; 1578 } 1579 IsUint8Array(napi_env env,napi_callback_info info)1580 static napi_value IsUint8Array(napi_env env, napi_callback_info info) 1581 { 1582 napi_value thisVar = nullptr; 1583 size_t requireArgc = 1; 1584 size_t argc = 1; 1585 napi_value args = nullptr; 1586 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1587 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1588 Types* object = nullptr; 1589 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1590 napi_value result = object->IsUint8Array(env, args); 1591 return result; 1592 } 1593 IsUint8ClampedArray(napi_env env,napi_callback_info info)1594 static napi_value IsUint8ClampedArray(napi_env env, napi_callback_info info) 1595 { 1596 napi_value thisVar = nullptr; 1597 size_t requireArgc = 1; 1598 size_t argc = 1; 1599 napi_value args = nullptr; 1600 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1601 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1602 Types* object = nullptr; 1603 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1604 napi_value result = object->IsUint8ClampedArray(env, args); 1605 return result; 1606 } 1607 IsUint16Array(napi_env env,napi_callback_info info)1608 static napi_value IsUint16Array(napi_env env, napi_callback_info info) 1609 { 1610 napi_value thisVar = nullptr; 1611 size_t requireArgc = 1; 1612 size_t argc = 1; 1613 napi_value args = nullptr; 1614 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1615 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1616 Types* object = nullptr; 1617 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1618 napi_value result = object->IsUint16Array(env, args); 1619 return result; 1620 } 1621 IsUint32Array(napi_env env,napi_callback_info info)1622 static napi_value IsUint32Array(napi_env env, napi_callback_info info) 1623 { 1624 napi_value thisVar = nullptr; 1625 size_t requireArgc = 1; 1626 size_t argc = 1; 1627 napi_value args = nullptr; 1628 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1629 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1630 Types* object = nullptr; 1631 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1632 napi_value result = object->IsUint32Array(env, args); 1633 return result; 1634 } 1635 IsWeakMap(napi_env env,napi_callback_info info)1636 static napi_value IsWeakMap(napi_env env, napi_callback_info info) 1637 { 1638 napi_value thisVar = nullptr; 1639 size_t requireArgc = 1; 1640 size_t argc = 1; 1641 napi_value args = nullptr; 1642 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1643 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1644 Types* object = nullptr; 1645 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1646 napi_value result = object->IsWeakMap(env, args); 1647 return result; 1648 } 1649 IsWeakSet(napi_env env,napi_callback_info info)1650 static napi_value IsWeakSet(napi_env env, napi_callback_info info) 1651 { 1652 napi_value thisVar = nullptr; 1653 size_t requireArgc = 1; 1654 size_t argc = 1; 1655 napi_value args = nullptr; 1656 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1657 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1658 Types* object = nullptr; 1659 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1660 napi_value result = object->IsWeakSet(env, args); 1661 return result; 1662 } 1663 1664 // StringDecoder StringDecoderConstructor(napi_env env,napi_callback_info info)1665 static napi_value StringDecoderConstructor(napi_env env, napi_callback_info info) 1666 { 1667 size_t argc = 1; 1668 napi_value thisVar = nullptr; 1669 napi_value argv = nullptr; 1670 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1671 std::string enconding = "utf-8"; 1672 if (argc == 1) { 1673 napi_valuetype valuetype; 1674 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1675 if (valuetype == napi_string) { 1676 size_t bufferSize = 0; 1677 if (napi_get_value_string_utf8(env, argv, nullptr, 0, &bufferSize) != napi_ok) { 1678 HILOG_ERROR("can not get argv size"); 1679 return nullptr; 1680 } 1681 std::string buffer = ""; 1682 buffer.reserve(bufferSize); 1683 buffer.resize(bufferSize); 1684 if (napi_get_value_string_utf8(env, argv, buffer.data(), bufferSize + 1, &bufferSize) != napi_ok) { 1685 HILOG_ERROR("can not get argv value"); 1686 return nullptr; 1687 } 1688 if (!CheckEncodingFormat(buffer)) { 1689 napi_throw_error(env, "401", 1690 "Parameter error. Wrong encoding format, the current encoding format is not support."); 1691 return nullptr; 1692 } 1693 enconding = buffer; 1694 } 1695 } 1696 auto objectInfo = new StringDecoder(enconding); 1697 napi_status status = napi_wrap(env, thisVar, objectInfo, 1698 [](napi_env environment, void* data, void* hint) { 1699 auto obj = reinterpret_cast<StringDecoder*>(data); 1700 if (obj != nullptr) { 1701 delete obj; 1702 obj = nullptr; 1703 } 1704 }, nullptr, nullptr); 1705 if (status != napi_ok && objectInfo != nullptr) { 1706 HILOG_ERROR("StringDecoderConstructor:: napi_wrap failed."); 1707 delete objectInfo; 1708 objectInfo = nullptr; 1709 } 1710 return thisVar; 1711 } 1712 Write(napi_env env,napi_callback_info info)1713 static napi_value Write(napi_env env, napi_callback_info info) 1714 { 1715 napi_value thisVar = nullptr; 1716 size_t argc = 1; 1717 napi_value argv = nullptr; 1718 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1719 napi_valuetype valuetype; 1720 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1721 if (valuetype == napi_string) { 1722 return argv; 1723 } 1724 StringDecoder *object = nullptr; 1725 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1726 return object->Write(env, argv); 1727 } 1728 End(napi_env env,napi_callback_info info)1729 static napi_value End(napi_env env, napi_callback_info info) 1730 { 1731 napi_value thisVar = nullptr; 1732 size_t argc = 1; 1733 napi_value argv = nullptr; 1734 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1735 StringDecoder *object = nullptr; 1736 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1737 if (argc == 0) { 1738 return object->End(env); 1739 } 1740 napi_valuetype valuetype; 1741 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1742 if (valuetype == napi_string) { 1743 return argv; 1744 } 1745 if (valuetype == napi_undefined) { 1746 return object->End(env); 1747 } 1748 return object->End(env, argv); 1749 } 1750 TypeofInit(napi_env env,napi_value exports)1751 static napi_value TypeofInit(napi_env env, napi_value exports) 1752 { 1753 const char* typeofClassName = "Types"; 1754 napi_value typeofClass = nullptr; 1755 napi_property_descriptor typeofDesc[] = { 1756 DECLARE_NAPI_FUNCTION("isBigInt64Array", IsBigInt64Array), 1757 DECLARE_NAPI_FUNCTION("isBigUint64Array", IsBigUint64Array), 1758 DECLARE_NAPI_FUNCTION("isBooleanObject", IsBooleanObject), 1759 DECLARE_NAPI_FUNCTION("isBoxedPrimitive", IsBoxedPrimitive), 1760 DECLARE_NAPI_FUNCTION("isAnyArrayBuffer", IsAnyArrayBuffer), 1761 DECLARE_NAPI_FUNCTION("isArrayBufferView", IsArrayBufferView), 1762 DECLARE_NAPI_FUNCTION("isArgumentsObject", IsArgumentsObject), 1763 DECLARE_NAPI_FUNCTION("isArrayBuffer", IsArrayBuffer), 1764 DECLARE_NAPI_FUNCTION("isDataView", IsDataView), 1765 DECLARE_NAPI_FUNCTION("isDate", IsDate), 1766 DECLARE_NAPI_FUNCTION("isExternal", IsExternal), 1767 DECLARE_NAPI_FUNCTION("isFloat32Array", IsFloat32Array), 1768 DECLARE_NAPI_FUNCTION("isFloat64Array", IsFloat64Array), 1769 DECLARE_NAPI_FUNCTION("isGeneratorFunction", IsGeneratorFunction), 1770 DECLARE_NAPI_FUNCTION("isGeneratorObject", IsGeneratorObject), 1771 DECLARE_NAPI_FUNCTION("isInt8Array", IsInt8Array), 1772 DECLARE_NAPI_FUNCTION("isInt16Array", IsInt16Array), 1773 DECLARE_NAPI_FUNCTION("isInt32Array", IsInt32Array), 1774 DECLARE_NAPI_FUNCTION("isMap", IsMap), 1775 DECLARE_NAPI_FUNCTION("isMapIterator", IsMapIterator), 1776 DECLARE_NAPI_FUNCTION("isModuleNamespaceObject", IsModuleNamespaceObject), 1777 DECLARE_NAPI_FUNCTION("isNativeError", IsNativeError), 1778 DECLARE_NAPI_FUNCTION("isNumberObject", IsNumberObject), 1779 DECLARE_NAPI_FUNCTION("isPromise", IsPromise), 1780 DECLARE_NAPI_FUNCTION("isProxy", IsProxy), 1781 DECLARE_NAPI_FUNCTION("isRegExp", IsRegExp), 1782 DECLARE_NAPI_FUNCTION("isSet", IsSet), 1783 DECLARE_NAPI_FUNCTION("isSetIterator", IsSetIterator), 1784 DECLARE_NAPI_FUNCTION("isSharedArrayBuffer", IsSharedArrayBuffer), 1785 DECLARE_NAPI_FUNCTION("isStringObject", IsStringObject), 1786 DECLARE_NAPI_FUNCTION("isSymbolObject", IsSymbolObject), 1787 DECLARE_NAPI_FUNCTION("isTypedArray", IsTypedArray), 1788 DECLARE_NAPI_FUNCTION("isUint8Array", IsUint8Array), 1789 DECLARE_NAPI_FUNCTION("isUint8ClampedArray", IsUint8ClampedArray), 1790 DECLARE_NAPI_FUNCTION("isUint16Array", IsUint16Array), 1791 DECLARE_NAPI_FUNCTION("isUint32Array", IsUint32Array), 1792 DECLARE_NAPI_FUNCTION("isWeakMap", IsWeakMap), 1793 DECLARE_NAPI_FUNCTION("isWeakSet", IsWeakSet), 1794 DECLARE_NAPI_FUNCTION("isAsyncFunction", IsAsyncFunction), 1795 }; 1796 NAPI_CALL(env, napi_define_class(env, typeofClassName, strlen(typeofClassName), TypesConstructor, 1797 nullptr, sizeof(typeofDesc) / sizeof(typeofDesc[0]), typeofDesc, 1798 &typeofClass)); 1799 napi_property_descriptor desc[] = { DECLARE_NAPI_PROPERTY("Types", typeofClass) }; 1800 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1801 return exports; 1802 } 1803 Base64Init(napi_env env,napi_value exports)1804 static napi_value Base64Init(napi_env env, napi_value exports) 1805 { 1806 const char *base64ClassName = "Base64"; 1807 napi_value base64Class = nullptr; 1808 napi_property_descriptor base64Desc[] = { 1809 DECLARE_NAPI_FUNCTION("encodeSync", EncodeBase64), 1810 DECLARE_NAPI_FUNCTION("encodeToStringSync", EncodeToString), 1811 DECLARE_NAPI_FUNCTION("decodeSync", DecodeBase64), 1812 DECLARE_NAPI_FUNCTION("encode", EncodeAsync), 1813 DECLARE_NAPI_FUNCTION("encodeToString", EncodeToStringAsync), 1814 DECLARE_NAPI_FUNCTION("decode", DecodeAsync), 1815 }; 1816 NAPI_CALL(env, napi_define_class(env, base64ClassName, strlen(base64ClassName), Base64Constructor, 1817 nullptr, sizeof(base64Desc) / sizeof(base64Desc[0]), base64Desc, 1818 &base64Class)); 1819 napi_property_descriptor desc[] = { 1820 DECLARE_NAPI_PROPERTY("Base64", base64Class) 1821 }; 1822 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1823 return exports; 1824 } 1825 Base64HelperInit(napi_env env,napi_value exports)1826 static napi_value Base64HelperInit(napi_env env, napi_value exports) 1827 { 1828 const char *base64HelperClassName = "Base64Helper"; 1829 napi_value Base64HelperClass = nullptr; 1830 napi_property_descriptor Base64HelperDesc[] = { 1831 DECLARE_NAPI_FUNCTION("encodeSync", EncodeBase64Helper), 1832 DECLARE_NAPI_FUNCTION("encodeToStringSync", EncodeToStringHelper), 1833 DECLARE_NAPI_FUNCTION("decodeSync", DecodeBase64Helper), 1834 DECLARE_NAPI_FUNCTION("encode", EncodeAsyncHelper), 1835 DECLARE_NAPI_FUNCTION("encodeToString", EncodeToStringAsyncHelper), 1836 DECLARE_NAPI_FUNCTION("decode", DecodeAsyncHelper), 1837 }; 1838 NAPI_CALL(env, napi_define_class(env, base64HelperClassName, strlen(base64HelperClassName), Base64Constructor, 1839 nullptr, sizeof(Base64HelperDesc) / sizeof(Base64HelperDesc[0]), 1840 Base64HelperDesc, &Base64HelperClass)); 1841 napi_property_descriptor desc[] = { 1842 DECLARE_NAPI_PROPERTY("Base64Helper", Base64HelperClass) 1843 }; 1844 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1845 return exports; 1846 } 1847 StringDecoderInit(napi_env env,napi_value exports)1848 static napi_value StringDecoderInit(napi_env env, napi_value exports) 1849 { 1850 const char *stringDecoderClassName = "StringDecoder"; 1851 napi_value StringDecoderClass = nullptr; 1852 napi_property_descriptor StringDecoderDesc[] = { 1853 DECLARE_NAPI_FUNCTION("write", Write), 1854 DECLARE_NAPI_FUNCTION("end", End), 1855 }; 1856 NAPI_CALL(env, napi_define_class(env, stringDecoderClassName, strlen(stringDecoderClassName), 1857 StringDecoderConstructor, nullptr, 1858 sizeof(StringDecoderDesc) / sizeof(StringDecoderDesc[0]), 1859 StringDecoderDesc, &StringDecoderClass)); 1860 napi_property_descriptor desc[] = { 1861 DECLARE_NAPI_PROPERTY("StringDecoder", StringDecoderClass) 1862 }; 1863 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1864 return exports; 1865 } 1866 UtilInit(napi_env env,napi_value exports)1867 static napi_value UtilInit(napi_env env, napi_value exports) 1868 { 1869 napi_property_descriptor desc[] = { 1870 DECLARE_NAPI_FUNCTION("printf", Printf), 1871 DECLARE_NAPI_FUNCTION("format", Printf), 1872 DECLARE_NAPI_FUNCTION("geterrorstring", GetErrorString), 1873 DECLARE_NAPI_FUNCTION("errnoToString", GetErrorString), 1874 DECLARE_NAPI_FUNCTION("dealwithformatstring", DealWithFormatString), 1875 DECLARE_NAPI_FUNCTION("randomUUID", RandomUUID), 1876 DECLARE_NAPI_FUNCTION("randomBinaryUUID", RandomBinaryUUID), 1877 DECLARE_NAPI_FUNCTION("parseUUID", ParseUUID), 1878 DECLARE_NAPI_FUNCTION("getHash", GetHash) 1879 }; 1880 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1881 TextcoderInit(env, exports); 1882 Base64Init(env, exports); 1883 Base64HelperInit(env, exports); 1884 TypeofInit(env, exports); 1885 StringDecoderInit(env, exports); 1886 return exports; 1887 } 1888 1889 // util JS register 1890 extern "C" NAPI_util_GetJSCode(const char ** buf,int * buflen)1891 __attribute__((visibility("default"))) void NAPI_util_GetJSCode(const char **buf, int *buflen) 1892 { 1893 if (buf != nullptr) { 1894 *buf = _binary_util_js_js_start; 1895 } 1896 if (buflen != nullptr) { 1897 *buflen = _binary_util_js_js_end - _binary_util_js_js_start; 1898 } 1899 } 1900 extern "C" NAPI_util_GetABCCode(const char ** buf,int * buflen)1901 __attribute__((visibility("default"))) void NAPI_util_GetABCCode(const char** buf, int* buflen) 1902 { 1903 if (buf != nullptr) { 1904 *buf = _binary_util_abc_start; 1905 } 1906 if (buflen != nullptr) { 1907 *buflen = _binary_util_abc_end - _binary_util_abc_start; 1908 } 1909 } 1910 1911 // util module define 1912 static napi_module_with_js utilModule = { 1913 .nm_version = 1, 1914 .nm_flags = 0, 1915 .nm_filename = nullptr, 1916 .nm_register_func = UtilInit, 1917 .nm_modname = "util", 1918 .nm_priv = ((void*)0), 1919 .nm_get_abc_code = NAPI_util_GetABCCode, 1920 .nm_get_js_code = NAPI_util_GetJSCode, 1921 }; 1922 // util module register 1923 extern "C" UtilRegisterModule()1924 __attribute__((constructor)) void UtilRegisterModule() 1925 { 1926 napi_module_with_js_register(&utilModule); 1927 UtilPluginJniRegister(); 1928 } 1929 } 1930