1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "napi/native_api.h"
17 #include "rawfile/raw_file_manager.h"
18 #include "rawfile/raw_file.h"
19 #include "rawfile/raw_dir.h"
20 #include "hilog/log.h"
21 #include <js_native_api.h>
22 #include <js_native_api_types.h>
23 #include <vector>
24 #include <resourcemanager/ohresmgr.h>
25 #include <string>
26 #include <sstream>
27
28 const int SUBLEN = 100;
GetFileList(napi_env env,napi_callback_info info)29 static napi_value GetFileList(napi_env env, napi_callback_info info)
30 {
31 size_t argc = 2;
32 napi_value argv[2] = {nullptr};
33
34 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
35
36 napi_valuetype valueType;
37 napi_typeof(env, argv[0], &valueType);
38 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
39 size_t strSize;
40 char strBuf[256];
41 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
42 std::string filename(strBuf, strSize);
43 RawDir *rawDir = OH_ResourceManager_OpenRawDir(mNativeResMgr, filename.c_str());
44 int count = OH_ResourceManager_GetRawFileCount(rawDir);
45 std::vector<std::string> tempArray;
46 for (int i = 0; i < count; i++) {
47 std::string rawfilename = OH_ResourceManager_GetRawFileName(rawDir, i);
48 tempArray.emplace_back(rawfilename);
49 }
50
51 napi_value fileList;
52 napi_create_array(env, &fileList);
53 for (size_t i = 0; i < tempArray.size(); i++) {
54 napi_value jsString;
55 napi_create_string_utf8(env, tempArray[i].c_str(), NAPI_AUTO_LENGTH, &jsString);
56 napi_set_element(env, fileList, i, jsString);
57 }
58 OH_ResourceManager_CloseRawDir(rawDir);
59 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
60 return fileList;
61 }
62
CreateJsString(napi_env env,char * str)63 napi_value CreateJsString(napi_env env, char *str)
64 {
65 napi_value result;
66 if (napi_create_string_utf8(env, str, NAPI_AUTO_LENGTH, &result) != napi_ok) {
67 return result;
68 }
69 return result;
70 }
71
createJsFileDescriptor(napi_env env,RawFileDescriptor * descriptor)72 napi_value createJsFileDescriptor(napi_env env, RawFileDescriptor *descriptor)
73 {
74 napi_value result;
75 napi_status status = napi_create_object(env, &result);
76 if (status != napi_ok) {
77 return result;
78 }
79
80 napi_value fd;
81 status = napi_create_int32(env, descriptor->fd, &fd);
82 if (status != napi_ok) {
83 return result;
84 }
85 status = napi_set_named_property(env, result, "fd", fd);
86 if (status != napi_ok) {
87 return result;
88 }
89
90 napi_value offset;
91 status = napi_create_int32(env, descriptor->start, &offset);
92 if (status != napi_ok) {
93 return result;
94 }
95 status = napi_set_named_property(env, result, "offset", offset);
96 if (status != napi_ok) {
97 return result;
98 }
99
100 napi_value length;
101 status = napi_create_int32(env, descriptor->length, &length);
102 if (status != napi_ok) {
103 return result;
104 }
105 status = napi_set_named_property(env, result, "length", length);
106 if (status != napi_ok) {
107 return result;
108 }
109 return result;
110 }
111
CreateJsArrayValue(napi_env env,std::unique_ptr<uint8_t[]> & data,long length)112 napi_value CreateJsArrayValue(napi_env env, std::unique_ptr<uint8_t[]> &data, long length)
113 {
114 napi_value buffer;
115 napi_status status = napi_create_external_arraybuffer(env, data.get(), length,
116 [](napi_env env, void *data, void *hint) {
117 delete[] static_cast<char*>(data);
118 }, nullptr, &buffer);
119 if (status != napi_ok) {
120 return nullptr;
121 }
122 napi_value result = nullptr;
123 status = napi_create_typedarray(env, napi_uint8_array, length, buffer, 0, &result);
124 if (status != napi_ok) {
125 return nullptr;
126 }
127 data.release();
128 return result;
129 }
130
GetRawFileContent(napi_env env,napi_callback_info info)131 static napi_value GetRawFileContent(napi_env env, napi_callback_info info)
132 {
133 size_t argc = 2;
134 napi_value argv[2] = {nullptr};
135
136 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
137
138 napi_valuetype valueType;
139 napi_typeof(env, argv[0], &valueType);
140 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
141 size_t strSize;
142 char strBuf[256];
143 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
144 std::string filename(strBuf, strSize);
145 RawFile *rawFile = OH_ResourceManager_OpenRawFile(mNativeResMgr, filename.c_str());
146 if (rawFile != nullptr) {
147 return nullptr;
148 }
149 long len = OH_ResourceManager_GetRawFileSize(rawFile);
150 std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(len);
151
152 long offset = OH_ResourceManager_GetRawFileOffset(rawFile);
153 if (offset == 0) {
154 return nullptr;
155 }
156
157 long size = OH_ResourceManager_SeekRawFile(rawFile, 1, 0);
158 if (size == -1) {
159 return nullptr;
160 }
161
162 long offset1 = 0;
163 while (OH_ResourceManager_GetRawFileRemainingLength(rawFile) > 0) {
164 OH_ResourceManager_ReadRawFile(rawFile, data.get() + offset1, SUBLEN);
165 offset1 += SUBLEN;
166 }
167
168 OH_ResourceManager_CloseRawFile(rawFile);
169 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
170 return CreateJsArrayValue(env, data, len);
171 }
172
GetRawFileContent64(napi_env env,napi_callback_info info)173 static napi_value GetRawFileContent64(napi_env env, napi_callback_info info)
174 {
175 size_t argc = 2;
176 napi_value argv[2] = {nullptr};
177 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
178 napi_valuetype valueType;
179 napi_typeof(env, argv[0], &valueType);
180 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
181 size_t strSize;
182 char strBuf[256];
183 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
184 std::string filename(strBuf, strSize);
185 RawFile64 *rawFile = OH_ResourceManager_OpenRawFile64(mNativeResMgr, filename.c_str());
186 if (rawFile != nullptr) {
187 return nullptr;
188 }
189 long len = OH_ResourceManager_GetRawFileSize64(rawFile);
190 std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(len);
191
192 int64_t offset = OH_ResourceManager_GetRawFileOffset64(rawFile);
193 if (offset == 0) {
194 return nullptr;
195 }
196
197 int size = OH_ResourceManager_SeekRawFile64(rawFile, 1, 0);
198 if (size == -1) {
199 return nullptr;
200 }
201
202 int64_t offset1 = 0;
203 while (OH_ResourceManager_GetRawFileRemainingLength64(rawFile) > 0) {
204 OH_ResourceManager_ReadRawFile64(rawFile, data.get() + offset1, SUBLEN);
205 offset1 += SUBLEN;
206 }
207
208 OH_ResourceManager_CloseRawFile64(rawFile);
209 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
210 return CreateJsArrayValue(env, data, len);
211 }
212
createJsFileDescriptor(napi_env env,RawFileDescriptor & descriptor)213 napi_value createJsFileDescriptor(napi_env env, RawFileDescriptor &descriptor)
214 {
215 napi_value result;
216 napi_status status = napi_create_object(env, &result);
217 if (status != napi_ok) {
218 return result;
219 }
220
221 napi_value fd;
222 status = napi_create_int32(env, descriptor.fd, &fd);
223 if (status != napi_ok) {
224 return result;
225 }
226 status = napi_set_named_property(env, result, "fd", fd);
227 if (status != napi_ok) {
228 return result;
229 }
230
231 napi_value offset;
232 status = napi_create_int64(env, descriptor.start, &offset);
233 if (status != napi_ok) {
234 return result;
235 }
236 status = napi_set_named_property(env, result, "offset", offset);
237 if (status != napi_ok) {
238 return result;
239 }
240
241 napi_value length;
242 status = napi_create_int64(env, descriptor.length, &length);
243 if (status != napi_ok) {
244 return result;
245 }
246 status = napi_set_named_property(env, result, "length", length);
247 if (status != napi_ok) {
248 return result;
249 }
250 return result;
251 }
252
createJsFileDescriptor64(napi_env env,RawFileDescriptor64 * descriptor)253 napi_value createJsFileDescriptor64(napi_env env, RawFileDescriptor64 *descriptor)
254 {
255 napi_value result;
256 napi_status status = napi_create_object(env, &result);
257 if (status != napi_ok) {
258 return result;
259 }
260
261 napi_value fd;
262 status = napi_create_int32(env, descriptor->fd, &fd);
263 if (status != napi_ok) {
264 return result;
265 }
266 status = napi_set_named_property(env, result, "fd", fd);
267 if (status != napi_ok) {
268 return result;
269 }
270
271 napi_value offset;
272 status = napi_create_int64(env, descriptor->start, &offset);
273 if (status != napi_ok) {
274 return result;
275 }
276 status = napi_set_named_property(env, result, "offset", offset);
277 if (status != napi_ok) {
278 return result;
279 }
280
281 napi_value length;
282 status = napi_create_int64(env, descriptor->length, &length);
283 if (status != napi_ok) {
284 return result;
285 }
286 return result;
287 }
288
GetRawFileDescriptor(napi_env env,napi_callback_info info)289 static napi_value GetRawFileDescriptor(napi_env env, napi_callback_info info)
290 {
291 size_t argc = 2;
292 napi_value argv[2] = {nullptr};
293
294 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
295
296 napi_valuetype valueType;
297 napi_typeof(env, argv[0], &valueType);
298 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
299 size_t strSize;
300 char strBuf[256];
301 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
302 std::string filename(strBuf, strSize);
303 RawFile *rawFile = OH_ResourceManager_OpenRawFile(mNativeResMgr, filename.c_str());
304 RawFileDescriptor descriptor;
305 OH_ResourceManager_GetRawFileDescriptor(rawFile, descriptor);
306 OH_ResourceManager_ReleaseRawFileDescriptor(descriptor);
307
308 OH_ResourceManager_CloseRawFile(rawFile);
309 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
310 return createJsFileDescriptor(env, descriptor);
311 }
312
GetRawFileDescriptor64(napi_env env,napi_callback_info info)313 static napi_value GetRawFileDescriptor64(napi_env env, napi_callback_info info)
314 {
315 size_t argc = 2;
316 napi_value argv[2] = {nullptr};
317
318 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
319
320 napi_valuetype valueType;
321 napi_typeof(env, argv[0], &valueType);
322 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
323 size_t strSize;
324 char strBuf[256];
325 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
326 std::string filename(strBuf, strSize);
327 RawFile64 *rawFile = OH_ResourceManager_OpenRawFile64(mNativeResMgr, filename.c_str());
328 RawFileDescriptor64 *descriptor = new RawFileDescriptor64();
329 OH_ResourceManager_GetRawFileDescriptor64(rawFile, descriptor);
330 OH_ResourceManager_ReleaseRawFileDescriptor64(descriptor);
331
332 OH_ResourceManager_CloseRawFile64(rawFile);
333 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
334 return createJsFileDescriptor64(env, descriptor);
335 }
336
IsRawDir(napi_env env,napi_callback_info info)337 static napi_value IsRawDir(napi_env env, napi_callback_info info)
338 {
339 size_t argc = 2;
340 napi_value argv[2] = {nullptr};
341 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
342 size_t strSize;
343 char strBuf[256];
344 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
345 std::string filename(strBuf, strSize);
346 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
347 bool result = OH_ResourceManager_IsRawDir(mNativeResMgr, filename.c_str());
348 bool flag = (result == false);
349 napi_value value = nullptr;
350 napi_get_boolean(env, flag, &value);
351 return value;
352 }
353
GetDrawableDescriptor(napi_env env,napi_callback_info info)354 static napi_value GetDrawableDescriptor(napi_env env, napi_callback_info info)
355 {
356 size_t argc = 2;
357 napi_value args[2] = {nullptr};
358 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
359 ArkUI_DrawableDescriptor *drawable = nullptr;
360 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, args[0]);
361 uint32_t id = 0;
362 napi_get_value_uint32(env, args[1], &id);
363 ResourceManager_ErrorCode code = OH_ResourceManager_GetDrawableDescriptor(mNativeResMgr, id, &drawable);
364
365 bool flag = (drawable != nullptr && code == 0);
366 napi_value value = nullptr;
367 napi_get_boolean(env, flag, &value);
368 return value;
369 }
370
GetDrawableDescriptorByName(napi_env env,napi_callback_info info)371 static napi_value GetDrawableDescriptorByName(napi_env env, napi_callback_info info)
372 {
373 size_t argc = 2;
374 napi_value args[2] = {nullptr};
375 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
376 ArkUI_DrawableDescriptor *drawable = nullptr;
377 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, args[0]);
378 OH_ResourceManager_GetDrawableDescriptorByName(mNativeResMgr, "icon", &drawable);
379
380 bool flag = (drawable != nullptr);
381 napi_value value = nullptr;
382 napi_get_boolean(env, flag, &value);
383 return value;
384 }
385
GetMediaBase64(napi_env env,napi_callback_info info)386 static napi_value GetMediaBase64(napi_env env, napi_callback_info info)
387 {
388 size_t argc = 2;
389 napi_value argv[2] = {nullptr};
390 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
391
392 uint32_t id = 0;
393 napi_get_value_uint32(env, argv[1], &id);
394
395 char *result = nullptr;
396 uint64_t len = 0;
397 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
398 OH_ResourceManager_GetMediaBase64(mNativeResMgr, id, &result, &len);
399
400 bool flag = (result != nullptr && len != 0);
401 napi_value value = nullptr;
402 napi_get_boolean(env, flag, &value);
403 return value;
404 }
405
GetMediaBase64ByName(napi_env env,napi_callback_info info)406 static napi_value GetMediaBase64ByName(napi_env env, napi_callback_info info)
407 {
408 size_t argc = 2;
409 napi_value argv[2] = {nullptr};
410 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
411
412 char *result = nullptr;
413 uint64_t len = 0;
414 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
415 OH_ResourceManager_GetMediaBase64ByName(mNativeResMgr, "icon", &result, &len);
416
417 bool flag = (result != nullptr && len != 0);
418 napi_value value = nullptr;
419 napi_get_boolean(env, flag, &value);
420 return value;
421 }
422
GetMedia(napi_env env,napi_callback_info info)423 static napi_value GetMedia(napi_env env, napi_callback_info info)
424 {
425 size_t argc = 2;
426 napi_value argv[2] = {nullptr};
427 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
428
429 uint32_t id = 0;
430 napi_get_value_uint32(env, argv[1], &id);
431
432 uint8_t *result = nullptr;
433 uint64_t len = 0;
434 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
435 OH_ResourceManager_GetMedia(mNativeResMgr, id, &result, &len);
436
437 bool flag = (result != nullptr && len != 0);
438 napi_value value = nullptr;
439 napi_get_boolean(env, flag, &value);
440 return value;
441 }
442
GetMediaByName(napi_env env,napi_callback_info info)443 static napi_value GetMediaByName(napi_env env, napi_callback_info info)
444 {
445 size_t argc = 2;
446 napi_value argv[2] = {nullptr};
447 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
448
449 uint8_t *result = nullptr;
450 uint64_t len = 0;
451 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
452 OH_ResourceManager_GetMediaByName(mNativeResMgr, "icon", &result, &len);
453
454 bool flag = (result != nullptr && len != 0);
455 napi_value value = nullptr;
456 napi_get_boolean(env, flag, &value);
457 return value;
458 }
459
GetSymbolByName(napi_env env,napi_callback_info info)460 static napi_value GetSymbolByName(napi_env env, napi_callback_info info)
461 {
462 size_t argc = 2;
463 napi_value argv[2] = {nullptr};
464 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
465 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
466 uint32_t result = 0;
467 const char *name = "symbol_test";
468 ResourceManager_ErrorCode code = OH_ResourceManager_GetSymbolByName(mNativeResMgr, name, &result);
469
470 bool flag = (code == 0 && result == 983040);
471 napi_value value = nullptr;
472 napi_get_boolean(env, flag, &value);
473 return value;
474 }
475
GetSymbol(napi_env env,napi_callback_info info)476 static napi_value GetSymbol(napi_env env, napi_callback_info info)
477 {
478 size_t argc = 2;
479 napi_value argv[2] = {nullptr};
480 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
481 uint32_t id = 0;
482 uint32_t result = 0;
483 napi_get_value_uint32(env, argv[1], &id);
484 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
485 ResourceManager_ErrorCode code = OH_ResourceManager_GetSymbol(mNativeResMgr, id, &result);
486
487 bool flag = (code == 0 && result == 983040);
488 napi_value value = nullptr;
489 napi_get_boolean(env, flag, &value);
490 return value;
491 }
492
GetBoolByName(napi_env env,napi_callback_info info)493 static napi_value GetBoolByName(napi_env env, napi_callback_info info)
494 {
495 size_t argc = 2;
496 napi_value argv[2] = {nullptr};
497 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
498 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
499 bool result = false;
500 uint32_t id = 0;
501 napi_get_value_uint32(env, argv[1], &id);
502 const char *name = "boolean_one";
503 ResourceManager_ErrorCode code = OH_ResourceManager_GetBoolByName(mNativeResMgr, name, &result);
504
505 bool flag = (code == 0 && result == true);
506 napi_value value = nullptr;
507 napi_get_boolean(env, flag, &value);
508 return value;
509 }
510
GetBool(napi_env env,napi_callback_info info)511 static napi_value GetBool(napi_env env, napi_callback_info info)
512 {
513 size_t argc = 2;
514 napi_value argv[2] = {nullptr};
515 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
516 uint32_t id = 0;
517 bool result = false;
518 napi_get_value_uint32(env, argv[1], &id);
519 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
520 ResourceManager_ErrorCode code = OH_ResourceManager_GetBool(mNativeResMgr, id, &result);
521
522 bool flag = (code == 0 && result == true);
523 napi_value value = nullptr;
524 napi_get_boolean(env, flag, &value);
525 return value;
526 }
527
GetPluralStringByName(napi_env env,napi_callback_info info)528 static napi_value GetPluralStringByName(napi_env env, napi_callback_info info)
529 {
530 size_t argc = 3;
531 napi_value argv[3] = {nullptr};
532 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
533 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
534 char *result;
535 uint32_t num = 1;
536 int second = 2;
537 napi_get_value_uint32(env, argv[second], &num);
538 const char *name = "eat_apple";
539 ResourceManager_ErrorCode code = OH_ResourceManager_GetPluralStringByName(mNativeResMgr, name, num, &result);
540
541 bool flag = (code == 0 && strcmp(result, "1 apples") == 0);
542 napi_value value = nullptr;
543 napi_get_boolean(env, flag, &value);
544 return value;
545 }
546
GetPluralString(napi_env env,napi_callback_info info)547 static napi_value GetPluralString(napi_env env, napi_callback_info info)
548 {
549 size_t argc = 3;
550 napi_value argv[3] = {nullptr};
551 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
552 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
553 char *result;
554 uint32_t resId = 0;
555 napi_get_value_uint32(env, argv[1], &resId);
556 uint32_t num = 0;
557 int second = 2;
558 napi_get_value_uint32(env, argv[second], &num);
559 ResourceManager_ErrorCode code = OH_ResourceManager_GetPluralString(mNativeResMgr, resId, num, &result);
560
561 bool flag = (code == 0 && strcmp(result, "1 apples") == 0);
562 napi_value value = nullptr;
563 napi_get_boolean(env, flag, &value);
564 return value;
565 }
566
GetColorByName(napi_env env,napi_callback_info info)567 static napi_value GetColorByName(napi_env env, napi_callback_info info)
568 {
569 size_t argc = 2;
570 napi_value argv[2] = {nullptr};
571 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
572 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
573 uint32_t result;
574 const char *name = "start_window_background_test";
575 OH_ResourceManager_GetColorByName(mNativeResMgr, name, &result);
576
577 napi_value jsValue = nullptr;
578 napi_create_uint32(env, result, &jsValue);
579 return jsValue;
580 }
581
GetColor(napi_env env,napi_callback_info info)582 static napi_value GetColor(napi_env env, napi_callback_info info)
583 {
584 size_t argc = 2;
585 napi_value argv[2] = {nullptr};
586 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
587 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
588 uint32_t result;
589 uint32_t resId = 0;
590 napi_get_value_uint32(env, argv[1], &resId);
591 OH_ResourceManager_GetColor(mNativeResMgr, resId, &result);
592
593 napi_value jsValue = nullptr;
594 napi_create_uint32(env, result, &jsValue);
595 return jsValue;
596 }
597
GetIntByName(napi_env env,napi_callback_info info)598 static napi_value GetIntByName(napi_env env, napi_callback_info info)
599 {
600 size_t argc = 2;
601 napi_value argv[2] = {nullptr};
602 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
603 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
604 int result;
605 const char *name = "integer_one";
606 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntByName(mNativeResMgr, name, &result);
607
608 bool flag = (code == 0 && result == 100);
609 napi_value value = nullptr;
610 napi_get_boolean(env, flag, &value);
611 return value;
612 }
613
GetInt(napi_env env,napi_callback_info info)614 static napi_value GetInt(napi_env env, napi_callback_info info)
615 {
616 size_t argc = 2;
617 napi_value argv[2] = {nullptr};
618 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
619 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
620 int result;
621 uint32_t resId = 0;
622 napi_get_value_uint32(env, argv[1], &resId);
623 ResourceManager_ErrorCode code = OH_ResourceManager_GetInt(mNativeResMgr, resId, &result);
624
625 bool flag = (code == 0 && result == 100);
626 napi_value value = nullptr;
627 napi_get_boolean(env, flag, &value);
628 return value;
629 }
630
GetFloatByName(napi_env env,napi_callback_info info)631 static napi_value GetFloatByName(napi_env env, napi_callback_info info)
632 {
633 size_t argc = 2;
634 napi_value argv[2] = {nullptr};
635 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
636 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
637 float result;
638 const char *name = "float_one";
639 ResourceManager_ErrorCode code = OH_ResourceManager_GetFloatByName(mNativeResMgr, name, &result);
640
641 bool flag = (code == 0 && (fabs(result - 30.6) >= 1e-9));
642 napi_value value = nullptr;
643 napi_get_boolean(env, flag, &value);
644 return value;
645 }
646
GetFloat(napi_env env,napi_callback_info info)647 static napi_value GetFloat(napi_env env, napi_callback_info info)
648 {
649 size_t argc = 2;
650 napi_value argv[2] = {nullptr};
651 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
652 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
653 float result;
654 uint32_t resId = 0;
655 napi_get_value_uint32(env, argv[1], &resId);
656 ResourceManager_ErrorCode code = OH_ResourceManager_GetFloat(mNativeResMgr, resId, &result);
657
658 bool flag = (code == 0 && (fabs(result - 30.6) >= 1e-9));
659 napi_value value = nullptr;
660 napi_get_boolean(env, flag, &value);
661 return value;
662 }
663
GetLocales(napi_env env,napi_callback_info info)664 static napi_value GetLocales(napi_env env, napi_callback_info info)
665 {
666 size_t argc = 3;
667 napi_value argv[3] = {nullptr};
668 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
669 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
670
671 char **resultValue;
672 uint32_t resultLen;
673 bool includeSystem = false;
674 OH_ResourceManager_GetLocales(mNativeResMgr, &resultValue, &resultLen, includeSystem);
675
676 std::vector<std::string> tempArray;
677 for (uint32_t i = 0; i < resultLen; i++) {
678 tempArray.push_back(resultValue[i]);
679 }
680 napi_value jsStringArray;
681 napi_create_array(env, &jsStringArray);
682 for (size_t i = 0; i < tempArray.size(); i++) {
683 napi_value jsString;
684 napi_create_string_utf8(env, tempArray[i].c_str(), NAPI_AUTO_LENGTH, &jsString);
685 napi_set_element(env, jsStringArray, i, jsString);
686 }
687 return jsStringArray;
688 }
689
GetConfiguration(napi_env env,napi_callback_info info)690 static napi_value GetConfiguration(napi_env env, napi_callback_info info)
691 {
692 size_t argc = 1;
693 napi_value argv[1] = {nullptr};
694 ResourceManager_Configuration config;
695 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
696 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
697 ResourceManager_ErrorCode code = OH_ResourceManager_GetConfiguration(mNativeResMgr, &config);
698
699 bool flag = (code == 0);
700 napi_value value = nullptr;
701 napi_get_boolean(env, flag, &value);
702 return value;
703 }
704
GetStringArray(napi_env env,napi_callback_info info)705 static napi_value GetStringArray(napi_env env, napi_callback_info info)
706 {
707 size_t argc = 2;
708 napi_value argv[2] = {nullptr};
709 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
710 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
711 char **resultValue;
712 uint32_t resultLen;
713 uint32_t resId = 0;
714 napi_get_value_uint32(env, argv[1], &resId);
715 OH_ResourceManager_GetStringArray(mNativeResMgr, resId, &resultValue, &resultLen);
716
717 std::vector<std::string> tempArray;
718 for (uint32_t i = 0; i < resultLen; i++) {
719 tempArray.push_back(resultValue[i]);
720 }
721 napi_value jsStringArray;
722 napi_create_array(env, &jsStringArray);
723 for (size_t i = 0; i < tempArray.size(); i++) {
724 napi_value jsString;
725 napi_create_string_utf8(env, tempArray[i].c_str(), NAPI_AUTO_LENGTH, &jsString);
726 napi_set_element(env, jsStringArray, i, jsString);
727 }
728 return jsStringArray;
729 }
730
GetStringArrayByName(napi_env env,napi_callback_info info)731 static napi_value GetStringArrayByName(napi_env env, napi_callback_info info)
732 {
733 size_t argc = 2;
734 napi_value argv[2] = {nullptr};
735 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
736 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
737 char **resultValue;
738 uint32_t resultLen;
739 const char *name = "size";
740 OH_ResourceManager_GetStringArrayByName(mNativeResMgr, name, &resultValue, &resultLen);
741
742 std::vector<std::string> tempArray;
743 for (uint32_t i = 0; i < resultLen; i++) {
744 tempArray.push_back(resultValue[i]);
745 }
746 napi_value jsStringArray;
747 napi_create_array(env, &jsStringArray);
748 for (size_t i = 0; i < tempArray.size(); i++) {
749 napi_value jsString;
750 napi_create_string_utf8(env, tempArray[i].c_str(), NAPI_AUTO_LENGTH, &jsString);
751 napi_set_element(env, jsStringArray, i, jsString);
752 }
753 return jsStringArray;
754 }
755
ReleaseStringArray(napi_env env,napi_callback_info info)756 static napi_value ReleaseStringArray(napi_env env, napi_callback_info info)
757 {
758 size_t argc = 2;
759 napi_value argv[2] = {nullptr};
760 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
761 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
762 char **resultValue;
763 char **resultValueTemp = nullptr;
764 uint32_t resultLen;
765 const char *name = "size";
766 ResourceManager_ErrorCode code;
767 OH_ResourceManager_GetStringArrayByName(mNativeResMgr, name, &resultValue, &resultLen);
768 resultValueTemp = resultValue;
769 code = OH_ResourceManager_ReleaseStringArray(&resultValue, resultLen);
770
771 bool flag = (code == 0 && resultValueTemp != nullptr && resultValue == nullptr);
772 napi_value value = nullptr;
773 napi_get_boolean(env, flag, &value);
774 return value;
775 }
776
ReleaseConfiguration(napi_env env,napi_callback_info info)777 static napi_value ReleaseConfiguration(napi_env env, napi_callback_info info)
778 {
779 size_t argc = 1;
780 napi_value argv[1] = {nullptr};
781 ResourceManager_Configuration config;
782 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
783 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
784 ResourceManager_ErrorCode code;
785 char *temp = static_cast<char *>(malloc(20 * sizeof(char)));
786 OH_ResourceManager_GetConfiguration(mNativeResMgr, &config);
787 static const int MAX_LENGTH = 20;
788 strncpy(temp, config.locale, MAX_LENGTH);
789 temp[MAX_LENGTH - 1] = '\0';
790 code = OH_ResourceManager_ReleaseConfiguration(&config);
791
792 bool flag = (code == 0 && strcmp(temp, "zh_Hans_CN") == 0 && config.locale == nullptr);
793 napi_value value = nullptr;
794 napi_get_boolean(env, flag, &value);
795 free(temp);
796 return value;
797 }
798
GetStringByName(napi_env env,napi_callback_info info)799 static napi_value GetStringByName(napi_env env, napi_callback_info info)
800 {
801 size_t argc = 2;
802 napi_value argv[2] = {nullptr};
803 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
804 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
805 char *result;
806 ResourceManager_ErrorCode code = OH_ResourceManager_GetStringByName(mNativeResMgr, "entry_MainAbility", &result);
807
808 bool flag = (code == 0 && strcmp(result, "entry_MainAbility") == 0);
809 napi_value value = nullptr;
810 napi_get_boolean(env, flag, &value);
811 return value;
812 }
813
GetString(napi_env env,napi_callback_info info)814 static napi_value GetString(napi_env env, napi_callback_info info)
815 {
816 size_t argc = 2;
817 napi_value argv[2] = {nullptr};
818 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
819 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
820 char *result;
821 uint32_t resId = 0;
822 napi_get_value_uint32(env, argv[1], &resId);
823 ResourceManager_ErrorCode code = OH_ResourceManager_GetString(mNativeResMgr, resId, &result);
824
825 bool flag = (code == 0 && strcmp(result, "entry_MainAbility") == 0);
826 napi_value value = nullptr;
827 napi_get_boolean(env, flag, &value);
828 return value;
829 }
830
GetRawFileDescriptorData(napi_env env,napi_callback_info info)831 static napi_value GetRawFileDescriptorData(napi_env env, napi_callback_info info)
832 {
833 size_t argc = 2;
834 napi_value argv[2] = {nullptr};
835 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
836 napi_valuetype valueType;
837 napi_typeof(env, argv[0], &valueType);
838 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
839 size_t strSize;
840 char strBuf[256];
841
842 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
843 std::string filename(strBuf, strSize);
844 RawFile *rawFile = OH_ResourceManager_OpenRawFile(mNativeResMgr, filename.c_str());
845 RawFileDescriptor *descriptor = new RawFileDescriptor();
846 OH_ResourceManager_GetRawFileDescriptorData(rawFile, descriptor);
847 OH_ResourceManager_ReleaseRawFileDescriptorData(descriptor);
848 OH_ResourceManager_GetRawFileDescriptorData(rawFile, descriptor);
849 OH_ResourceManager_CloseRawFile(rawFile);
850 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
851 return createJsFileDescriptor(env, descriptor);
852 }
853
GetLocalesData(napi_env env,napi_callback_info info)854 static napi_value GetLocalesData(napi_env env, napi_callback_info info)
855 {
856 size_t argc = 1;
857 napi_value argv[1] = {nullptr};
858 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
859 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
860 char **resultValue;
861 uint32_t resultLen;
862 OH_ResourceManager_GetLocalesData(mNativeResMgr, &resultValue, &resultLen, false);
863 char **resultValue1;
864 uint32_t resultLen1;
865 OH_ResourceManager_GetLocalesData(mNativeResMgr, &resultValue1, &resultLen1, false);
866 std::vector<std::string> tempArray;
867 for (uint32_t i = 0; i < resultLen; i++) {
868 tempArray.push_back(resultValue[i]);
869 }
870 napi_value jsStringArray;
871 napi_create_array(env, &jsStringArray);
872 for (size_t i = 0; i < tempArray.size(); i++) {
873 napi_value jsString;
874 napi_create_string_utf8(env, tempArray[i].c_str(), NAPI_AUTO_LENGTH, &jsString);
875 napi_set_element(env, jsStringArray, i, jsString);
876 }
877 return jsStringArray;
878 }
879
GetMediaBase64DataByName(napi_env env,napi_callback_info info)880 static napi_value GetMediaBase64DataByName(napi_env env, napi_callback_info info)
881 {
882 size_t argc = 2;
883 napi_value argv[2] = {nullptr};
884 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
885 size_t strSize;
886 char strBuf[256];
887 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
888 char *result = nullptr;
889 uint64_t len = 0;
890 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
891 OH_ResourceManager_GetMediaBase64DataByName(mNativeResMgr, strBuf, &result, &len, 0);
892 return CreateJsString(env, result);
893 }
894
GetMediaBase64Data(napi_env env,napi_callback_info info)895 static napi_value GetMediaBase64Data(napi_env env, napi_callback_info info)
896 {
897 size_t argc = 2;
898 napi_value argv[2] = {nullptr};
899 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
900 uint32_t id = 0x000000;
901 napi_get_value_uint32(env, argv[1], &id);
902
903 std::stringstream ss;
904 ss << std::hex << id;
905 uint32_t hexValue;
906 ss >> hexValue;
907
908 char *result = nullptr;
909 uint64_t len = 0;
910 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
911 OH_ResourceManager_GetMediaBase64Data(mNativeResMgr, hexValue, &result, &len, 0);
912 return CreateJsString(env, result);
913 }
914
GetMediaData(napi_env env,napi_callback_info info)915 static napi_value GetMediaData(napi_env env, napi_callback_info info)
916 {
917 size_t argc = 2;
918 napi_value argv[2] = {nullptr};
919 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
920 uint32_t id = 0;
921 napi_get_value_uint32(env, argv[1], &id);
922
923 uint8_t *result = nullptr;
924 uint64_t len = 0;
925 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
926 OH_ResourceManager_GetMediaData(mNativeResMgr, id, &result, &len, 0);
927
928 bool flag = (result != nullptr && len != 0);
929 napi_value value = nullptr;
930 napi_get_boolean(env, flag, &value);
931 return value;
932 }
933
GetMediaDataByName(napi_env env,napi_callback_info info)934 static napi_value GetMediaDataByName(napi_env env, napi_callback_info info)
935 {
936 size_t argc = 2;
937 napi_value argv[2] = {nullptr};
938 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
939 size_t strSize;
940 char strBuf[256];
941 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
942
943 uint8_t *result = nullptr;
944 uint64_t len = 0;
945 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
946 OH_ResourceManager_GetMediaDataByName(mNativeResMgr, strBuf, &result, &len, 0);
947
948 bool flag = (result != nullptr && len != 0);
949 napi_value value = nullptr;
950 napi_get_boolean(env, flag, &value);
951 return value;
952 }
953
GetDrawableDescriptorData(napi_env env,napi_callback_info info)954 static napi_value GetDrawableDescriptorData(napi_env env, napi_callback_info info)
955 {
956 size_t argc = 2;
957 napi_value argv[2] = {nullptr};
958 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
959 ArkUI_DrawableDescriptor *drawable = nullptr;
960 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
961
962 uint32_t id = 0x000000;
963 napi_get_value_uint32(env, argv[1], &id);
964
965 std::stringstream ss;
966 ss << std::hex << id;
967 uint32_t hexValue;
968 ss >> hexValue;
969
970 OH_ResourceManager_GetDrawableDescriptorData(mNativeResMgr, id, &drawable, 0, 0);
971 bool flag = (drawable != nullptr);
972 napi_value value = nullptr;
973 napi_get_boolean(env, flag, &value);
974 return value;
975 }
976
GetDrawableDescriptorDataByName(napi_env env,napi_callback_info info)977 static napi_value GetDrawableDescriptorDataByName(napi_env env, napi_callback_info info)
978 {
979 size_t argc = 2;
980 napi_value argv[2] = {nullptr};
981 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
982 size_t strSize;
983 char strBuf[256];
984 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
985 ArkUI_DrawableDescriptor *drawable = nullptr;
986 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
987
988 OH_ResourceManager_GetDrawableDescriptorDataByName(mNativeResMgr, strBuf, &drawable, 0, 0);
989 bool flag = (drawable != nullptr);
990 napi_value value = nullptr;
991 napi_get_boolean(env, flag, &value);
992 return value;
993 }
994
AddResource(napi_env env,napi_callback_info info)995 static napi_value AddResource(napi_env env, napi_callback_info info)
996 {
997 size_t argc = 2;
998 napi_value argv[2] = {nullptr};
999 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1000 ResourceManager_ErrorCode code = OH_ResourceManager_AddResource(nullptr, "");
1001 bool flag = (code == 401);
1002 napi_value value = nullptr;
1003 napi_get_boolean(env, flag, &value);
1004 return value;
1005 }
1006
RemoveResource(napi_env env,napi_callback_info info)1007 static napi_value RemoveResource(napi_env env, napi_callback_info info)
1008 {
1009 size_t argc = 2;
1010 napi_value argv[2] = {nullptr};
1011 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1012 ResourceManager_ErrorCode code = OH_ResourceManager_RemoveResource(nullptr, "");
1013 bool flag = (code == 401);
1014 napi_value value = nullptr;
1015 napi_get_boolean(env, flag, &value);
1016 return value;
1017 }
1018
GetRawFileContentTwo(napi_env env,napi_callback_info info)1019 static napi_value GetRawFileContentTwo(napi_env env, napi_callback_info info)
1020 {
1021 size_t argc = 2;
1022 napi_value argv[2] = {nullptr};
1023 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1024 napi_valuetype valueType;
1025 napi_typeof(env, argv[0], &valueType);
1026 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1027 size_t strSize, lenghtOne = 3, lenghtTwo = 5, lenghtThree = 8;
1028 long offsetOne = 0, offsetTwo = -5, offsetThree = 1;
1029 char strBuf[256];
1030
1031 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1032 std::string filename(strBuf, strSize);
1033 RawFile *rawFile = OH_ResourceManager_OpenRawFile(mNativeResMgr, filename.c_str());
1034 long len = OH_ResourceManager_GetRawFileSize(rawFile);
1035 std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(len);
1036 OH_ResourceManager_SeekRawFile(rawFile, offsetOne, SEEK_SET);
1037 OH_ResourceManager_ReadRawFile(rawFile, data.get(), lenghtOne);
1038 OH_ResourceManager_SeekRawFile(rawFile, offsetTwo, SEEK_END);
1039 OH_ResourceManager_ReadRawFile(rawFile, data.get() + lenghtOne, lenghtTwo);
1040 OH_ResourceManager_SeekRawFile(rawFile, offsetThree, SEEK_SET);
1041 OH_ResourceManager_ReadRawFile(rawFile, data.get() + lenghtThree, lenghtThree);
1042 OH_ResourceManager_CloseRawFile(rawFile);
1043 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1044 return CreateJsArrayValue(env, data, lenghtOne + lenghtTwo + lenghtThree);
1045 }
1046
testGetIntPluralStringById0790_082(napi_env env,napi_callback_info info)1047 static napi_value testGetIntPluralStringById0790_082(napi_env env, napi_callback_info info)
1048 {
1049 size_t argc = 2;
1050 napi_value argv[2] = {nullptr};
1051 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1052 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1053 char* result;
1054 uint32_t resId = 0;
1055 uint32_t num = 2;
1056 napi_get_value_uint32(env, argv[1], &resId);
1057 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralString(mNativeResMgr, resId, num, &result);
1058
1059 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1060 bool flag = (code == 0 && strcmp(result, "apples") == 0);
1061 napi_value value = nullptr;
1062 napi_get_boolean(env, flag, &value);
1063 return value;
1064 }
1065
testGetIntPluralStringByName0790_082(napi_env env,napi_callback_info info)1066 static napi_value testGetIntPluralStringByName0790_082(napi_env env, napi_callback_info info)
1067 {
1068 size_t argc = 2;
1069 napi_value argv[2] = {nullptr};
1070 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1071 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1072 char* result;
1073 size_t strSize;
1074 char strBuf[256];
1075 uint32_t num = 2;
1076 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1077 std::string resId(strBuf, strSize);
1078 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralStringByName(mNativeResMgr,
1079 resId.c_str(), num, &result);
1080
1081 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1082 bool flag = (code == 0 && strcmp(result, "apples") == 0);
1083 napi_value value = nullptr;
1084 napi_get_boolean(env, flag, &value);
1085 return value;
1086 }
1087
testGetDoublePluralStringById0790_082(napi_env env,napi_callback_info info)1088 static napi_value testGetDoublePluralStringById0790_082(napi_env env, napi_callback_info info)
1089 {
1090 size_t argc = 2;
1091 napi_value argv[2] = {nullptr};
1092 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1093 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1094 char* result;
1095 uint32_t resId = 0;
1096 float num = 2.1;
1097 napi_get_value_uint32(env, argv[1], &resId);
1098 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralString(mNativeResMgr, resId, num, &result);
1099
1100 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1101 bool flag = (code == 0 && strcmp(result, "apples") == 0);
1102 napi_value value = nullptr;
1103 napi_get_boolean(env, flag, &value);
1104 return value;
1105 }
1106
testGetDoublePluralStringByName0790_082(napi_env env,napi_callback_info info)1107 static napi_value testGetDoublePluralStringByName0790_082(napi_env env, napi_callback_info info)
1108 {
1109 size_t argc = 2;
1110 napi_value argv[2] = {nullptr};
1111 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1112 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1113 char* result;
1114 size_t strSize;
1115 char strBuf[271];
1116 float num = 2.1;
1117 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1118 std::string resId(strBuf, strSize);
1119 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralStringByName(mNativeResMgr,
1120 resId.c_str(), num, &result);
1121
1122 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1123 bool flag = (code == 0 && strcmp(result, "apples") == 0);
1124 napi_value value = nullptr;
1125 napi_get_boolean(env, flag, &value);
1126 return value;
1127 }
1128
testGetIntPluralStringById119(napi_env env,napi_callback_info info)1129 static napi_value testGetIntPluralStringById119(napi_env env, napi_callback_info info)
1130 {
1131 size_t argc = 2;
1132 napi_value argv[2] = {nullptr};
1133 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1134 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1135 char* result;
1136 uint32_t resId = 0;
1137 uint32_t num = 1;
1138 napi_get_value_uint32(env, argv[1], &resId);
1139 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralString(mNativeResMgr, resId, num, &result, num);
1140 code = OH_ResourceManager_GetIntPluralString(nullptr, resId, num, &result, num);
1141
1142 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1143 bool flag = (code == 401);
1144 napi_value value = nullptr;
1145 napi_get_boolean(env, flag, &value);
1146 return value;
1147 }
1148
testGetDoublePluralStringById120(napi_env env,napi_callback_info info)1149 static napi_value testGetDoublePluralStringById120(napi_env env, napi_callback_info info)
1150 {
1151 size_t argc = 2;
1152 napi_value argv[2] = {nullptr};
1153 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1154 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1155 char* result;
1156 uint32_t resId = 0;
1157 float num = 1.1;
1158 uint32_t numTest = 1;
1159 napi_get_value_uint32(env, argv[1], &resId);
1160 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralString(mNativeResMgr,
1161 resId, num, &result, numTest);
1162 code = OH_ResourceManager_GetDoublePluralString(nullptr, resId, num, &result, numTest);
1163
1164 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1165 bool flag = (code == 401);
1166 napi_value value = nullptr;
1167 napi_get_boolean(env, flag, &value);
1168 return value;
1169 }
1170
testGetIntPluralStringById125(napi_env env,napi_callback_info info)1171 static napi_value testGetIntPluralStringById125(napi_env env, napi_callback_info info)
1172 {
1173 size_t argc = 2;
1174 napi_value argv[2] = {nullptr};
1175 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1176 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1177 char* result;
1178 uint32_t resId = 0;
1179 uint32_t num = 1;
1180 uint32_t errorId = 0x12345678;
1181 napi_get_value_uint32(env, argv[1], &resId);
1182 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralString(mNativeResMgr, resId, num, &result, num);
1183 code = OH_ResourceManager_GetIntPluralString(mNativeResMgr, errorId, num, &result, num);
1184
1185 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1186 bool flag = (code == 9001001);
1187 napi_value value = nullptr;
1188 napi_get_boolean(env, flag, &value);
1189 return value;
1190 }
1191
testGetDoublePluralStringById126(napi_env env,napi_callback_info info)1192 static napi_value testGetDoublePluralStringById126(napi_env env, napi_callback_info info)
1193 {
1194 size_t argc = 2;
1195 napi_value argv[2] = {nullptr};
1196 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1197 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1198 char* result;
1199 uint32_t resId = 0;
1200 float num = 1.1;
1201 uint32_t numTest = 1;
1202 uint32_t errorId = 0x12345678;
1203 napi_get_value_uint32(env, argv[1], &resId);
1204 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralString(mNativeResMgr,
1205 resId, num, &result, numTest);
1206 code = OH_ResourceManager_GetDoublePluralString(mNativeResMgr, errorId, num, &result, numTest);
1207
1208 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1209 bool flag = (code == 9001001);
1210 napi_value value = nullptr;
1211 napi_get_boolean(env, flag, &value);
1212 return value;
1213 }
1214
testGetIntPluralStringById127(napi_env env,napi_callback_info info)1215 static napi_value testGetIntPluralStringById127(napi_env env, napi_callback_info info)
1216 {
1217 size_t argc = 3;
1218 napi_value argv[3] = {nullptr};
1219 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1220 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1221 char* result;
1222 uint32_t resId = 0;
1223 uint32_t resIdNext = 0;
1224 uint32_t num = 1;
1225 uint32_t numTwo = 2;
1226 napi_get_value_uint32(env, argv[1], &resId);
1227 napi_get_value_uint32(env, argv[numTwo], &resIdNext);
1228 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralString(mNativeResMgr, resId, num, &result, num);
1229 code = OH_ResourceManager_GetIntPluralString(mNativeResMgr, resIdNext, num, &result, num);
1230
1231 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1232 bool flag = (code == 9001002);
1233 napi_value value = nullptr;
1234 napi_get_boolean(env, flag, &value);
1235 return value;
1236 }
1237
testGetDoublePluralStringById128(napi_env env,napi_callback_info info)1238 static napi_value testGetDoublePluralStringById128(napi_env env, napi_callback_info info)
1239 {
1240 size_t argc = 3;
1241 napi_value argv[3] = {nullptr};
1242 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1243 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1244 char* result;
1245 uint32_t resId = 0;
1246 uint32_t resIdNext = 0;
1247 float num = 1.1;
1248 uint32_t numTest = 1;
1249 uint32_t numTwo = 2;
1250 napi_get_value_uint32(env, argv[1], &resId);
1251 napi_get_value_uint32(env, argv[numTwo], &resIdNext);
1252 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralString(mNativeResMgr,
1253 resId, num, &result, numTest);
1254 code = OH_ResourceManager_GetDoublePluralString(mNativeResMgr, resIdNext, num, &result, numTest);
1255
1256 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1257 bool flag = (code == 9001002);
1258 napi_value value = nullptr;
1259 napi_get_boolean(env, flag, &value);
1260 return value;
1261 }
1262
testGetIntPluralStringById129(napi_env env,napi_callback_info info)1263 static napi_value testGetIntPluralStringById129(napi_env env, napi_callback_info info)
1264 {
1265 size_t argc = 3;
1266 napi_value argv[3] = {nullptr};
1267 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1268 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1269 char* result;
1270 uint32_t resId = 0;
1271 uint32_t resIdNext = 0;
1272 uint32_t num = 1;
1273 uint32_t numTwo = 2;
1274 napi_get_value_uint32(env, argv[1], &resId);
1275 napi_get_value_uint32(env, argv[numTwo], &resIdNext);
1276 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralString(mNativeResMgr, resId, num, &result, num);
1277 code = OH_ResourceManager_GetIntPluralString(mNativeResMgr, resIdNext, num, &result, num);
1278
1279 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1280 bool flag = (code == 9001006);
1281 napi_value value = nullptr;
1282 napi_get_boolean(env, flag, &value);
1283 return value;
1284 }
1285
testGetDoublePluralStringById130(napi_env env,napi_callback_info info)1286 static napi_value testGetDoublePluralStringById130(napi_env env, napi_callback_info info)
1287 {
1288 size_t argc = 3;
1289 napi_value argv[3] = {nullptr};
1290 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1291 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1292 char* result;
1293 uint32_t resId = 0;
1294 uint32_t resIdNext = 0;
1295 float num = 1.1;
1296 uint32_t numTest = 1;
1297 uint32_t numTwo = 2;
1298 napi_get_value_uint32(env, argv[1], &resId);
1299 napi_get_value_uint32(env, argv[numTwo], &resIdNext);
1300 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralString(mNativeResMgr,
1301 resId, num, &result, numTest);
1302 code = OH_ResourceManager_GetDoublePluralString(mNativeResMgr, resIdNext, num, &result, numTest);
1303
1304 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1305 bool flag = (code == 9001006);
1306 napi_value value = nullptr;
1307 napi_get_boolean(env, flag, &value);
1308 return value;
1309 }
1310
testGetIntPluralStringByName133(napi_env env,napi_callback_info info)1311 static napi_value testGetIntPluralStringByName133(napi_env env, napi_callback_info info)
1312 {
1313 size_t argc = 2;
1314 napi_value argv[2] = {nullptr};
1315 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1316 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1317 char* result;
1318 size_t strSize;
1319 char strBuf[256];
1320 uint32_t num = 1;
1321 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1322 std::string resId(strBuf, strSize);
1323 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralStringByName(mNativeResMgr,
1324 resId.c_str(), num, &result, num);
1325 code = OH_ResourceManager_GetIntPluralStringByName(nullptr, resId.c_str(), num, &result, num);
1326
1327 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1328 bool flag = (code == 401);
1329 napi_value value = nullptr;
1330 napi_get_boolean(env, flag, &value);
1331 return value;
1332 }
1333
testGetDoublePluralStringByName134(napi_env env,napi_callback_info info)1334 static napi_value testGetDoublePluralStringByName134(napi_env env, napi_callback_info info)
1335 {
1336 size_t argc = 2;
1337 napi_value argv[2] = {nullptr};
1338 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1339 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1340 char* result;
1341 size_t strSize;
1342 char strBuf[271];
1343 float num = 1.1;
1344 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1345 std::string resId(strBuf, strSize);
1346 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralStringByName(mNativeResMgr,
1347 resId.c_str(), num, &result);
1348 code = OH_ResourceManager_GetDoublePluralStringByName(nullptr, resId.c_str(), num, &result);
1349
1350 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1351 bool flag = (code == 401);
1352 napi_value value = nullptr;
1353 napi_get_boolean(env, flag, &value);
1354 return value;
1355 }
1356
testGetIntPluralStringByName139(napi_env env,napi_callback_info info)1357 static napi_value testGetIntPluralStringByName139(napi_env env, napi_callback_info info)
1358 {
1359 size_t argc = 2;
1360 napi_value argv[2] = {nullptr};
1361 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1362 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1363 char* result;
1364 size_t strSize;
1365 char strBuf[256];
1366 uint32_t num = 1;
1367 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1368 std::string resId(strBuf, strSize);
1369 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralStringByName(mNativeResMgr,
1370 resId.c_str(), num, &result, num);
1371 code = OH_ResourceManager_GetIntPluralStringByName(mNativeResMgr, "error", num, &result, num);
1372
1373 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1374 bool flag = (code == 9001003);
1375 napi_value value = nullptr;
1376 napi_get_boolean(env, flag, &value);
1377 return value;
1378 }
1379
testGetDoublePluralStringByName140(napi_env env,napi_callback_info info)1380 static napi_value testGetDoublePluralStringByName140(napi_env env, napi_callback_info info)
1381 {
1382 size_t argc = 2;
1383 napi_value argv[2] = {nullptr};
1384 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1385 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1386 char* result;
1387 size_t strSize;
1388 char strBuf[271];
1389 float num = 1.1;
1390 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1391 std::string resId(strBuf, strSize);
1392 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralStringByName(mNativeResMgr,
1393 resId.c_str(), num, &result);
1394 code = OH_ResourceManager_GetDoublePluralStringByName(mNativeResMgr, "error", num, &result);
1395
1396 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1397 bool flag = (code == 9001003);
1398 napi_value value = nullptr;
1399 napi_get_boolean(env, flag, &value);
1400 return value;
1401 }
1402
testGetIntPluralStringByName141(napi_env env,napi_callback_info info)1403 static napi_value testGetIntPluralStringByName141(napi_env env, napi_callback_info info)
1404 {
1405 size_t argc = 2;
1406 napi_value argv[2] = {nullptr};
1407 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1408 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1409 char* result;
1410 size_t strSize;
1411 char strBuf[256];
1412 uint32_t num = 1;
1413 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1414 std::string resId(strBuf, strSize);
1415 ResourceManager_ErrorCode code = OH_ResourceManager_GetIntPluralStringByName(mNativeResMgr,
1416 resId.c_str(), num, &result, num);
1417 code = OH_ResourceManager_GetIntPluralStringByName(mNativeResMgr, "test_cyc", num, &result, num);
1418
1419 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1420 bool flag = (code == 9001006);
1421 napi_value value = nullptr;
1422 napi_get_boolean(env, flag, &value);
1423 return value;
1424 }
1425
testGetDoublePluralStringByName142(napi_env env,napi_callback_info info)1426 static napi_value testGetDoublePluralStringByName142(napi_env env, napi_callback_info info)
1427 {
1428 size_t argc = 2;
1429 napi_value argv[2] = {nullptr};
1430 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1431 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1432 char* result;
1433 size_t strSize;
1434 char strBuf[271];
1435 float num = 1.1;
1436 napi_get_value_string_utf8(env, argv[1], strBuf, sizeof(strBuf), &strSize);
1437 std::string resId(strBuf, strSize);
1438 ResourceManager_ErrorCode code = OH_ResourceManager_GetDoublePluralStringByName(mNativeResMgr,
1439 resId.c_str(), num, &result);
1440 code = OH_ResourceManager_GetDoublePluralStringByName(mNativeResMgr, "test_cyc", num, &result);
1441
1442 OH_ResourceManager_ReleaseNativeResourceManager(mNativeResMgr);
1443 bool flag = (code == 9001006);
1444 napi_value value = nullptr;
1445 napi_get_boolean(env, flag, &value);
1446 return value;
1447 }
1448
1449
GetResourceConfiguration(napi_env env,napi_callback_info info)1450 static napi_value GetResourceConfiguration(napi_env env, napi_callback_info info)
1451 {
1452 size_t argc = 1;
1453 napi_value argv[1] = {nullptr};
1454 ResourceManager_Configuration config;
1455 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1456 NativeResourceManager *mNativeResMgr = OH_ResourceManager_InitNativeResourceManager(env, argv[0]);
1457 ResourceManager_ErrorCode code = OH_ResourceManager_GetResourceConfiguration(mNativeResMgr, &config);
1458 ResourceManager_ErrorCode codeTwo = OH_ResourceManager_ReleaseConfiguration(&config);
1459
1460 bool flag = (code == 0 && codeTwo == 0);
1461 napi_value value = nullptr;
1462 napi_get_boolean(env, flag, &value);
1463 return value;
1464 }
1465
1466 EXTERN_C_START
Init(napi_env env,napi_value exports)1467 static napi_value Init(napi_env env, napi_value exports)
1468 {
1469 napi_property_descriptor desc[] = {
1470 {"getFileList", nullptr, GetFileList, nullptr, nullptr, nullptr, napi_default, nullptr},
1471 {"getRawFileContent", nullptr, GetRawFileContent, nullptr, nullptr, nullptr, napi_default, nullptr},
1472 {"getRawFileDescriptor", nullptr, GetRawFileDescriptor, nullptr, nullptr, nullptr, napi_default, nullptr},
1473 {"getRawFileContent64", nullptr, GetRawFileContent64, nullptr, nullptr, nullptr, napi_default, nullptr},
1474 {"getRawFileDescriptor64", nullptr, GetRawFileDescriptor64, nullptr, nullptr, nullptr, napi_default, nullptr},
1475 {"isRawDir", nullptr, IsRawDir, nullptr, nullptr, nullptr, napi_default, nullptr},
1476 {"getDrawableDescriptor", nullptr, GetDrawableDescriptor, nullptr, nullptr, nullptr, napi_default, nullptr},
1477 {"getDrawableDescriptorByName", nullptr, GetDrawableDescriptorByName, nullptr,
1478 nullptr, nullptr, napi_default, nullptr},
1479 {"getMediaBase64", nullptr, GetMediaBase64, nullptr, nullptr, nullptr, napi_default, nullptr},
1480 {"getMediaBase64ByName", nullptr, GetMediaBase64ByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1481 {"getMedia", nullptr, GetMedia, nullptr, nullptr, nullptr, napi_default, nullptr},
1482 {"getMediaByName", nullptr, GetMediaByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1483 {"getSymbolByName", nullptr, GetSymbolByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1484 {"getSymbol", nullptr, GetSymbol, nullptr, nullptr, nullptr, napi_default, nullptr},
1485 {"getBoolByName", nullptr, GetBoolByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1486 {"getBool", nullptr, GetBool, nullptr, nullptr, nullptr, napi_default, nullptr},
1487 {"getPluralStringByName", nullptr, GetPluralStringByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1488 {"getPluralString", nullptr, GetPluralString, nullptr, nullptr, nullptr, napi_default, nullptr},
1489 {"getColorByName", nullptr, GetColorByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1490 {"getColor", nullptr, GetColor, nullptr, nullptr, nullptr, napi_default, nullptr},
1491 {"getIntByName", nullptr, GetIntByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1492 {"getInt", nullptr, GetInt, nullptr, nullptr, nullptr, napi_default, nullptr},
1493 {"getFloatByName", nullptr, GetFloatByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1494 {"getFloat", nullptr, GetFloat, nullptr, nullptr, nullptr, napi_default, nullptr},
1495 {"getLocales", nullptr, GetLocales, nullptr, nullptr, nullptr, napi_default, nullptr},
1496 {"getConfiguration", nullptr, GetConfiguration, nullptr, nullptr, nullptr, napi_default, nullptr},
1497 {"getStringArray", nullptr, GetStringArray, nullptr, nullptr, nullptr, napi_default, nullptr},
1498 {"getStringArrayByName", nullptr, GetStringArrayByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1499 {"releaseStringArray", nullptr, ReleaseStringArray, nullptr, nullptr, nullptr, napi_default, nullptr},
1500 {"releaseConfiguration", nullptr, ReleaseConfiguration, nullptr, nullptr, nullptr, napi_default, nullptr},
1501 {"getStringByName", nullptr, GetStringByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1502 {"getString", nullptr, GetString, nullptr, nullptr, nullptr, napi_default, nullptr},
1503 {"getRawFileDescriptorData", nullptr, GetRawFileDescriptorData, nullptr, nullptr,
1504 nullptr, napi_default, nullptr},
1505 {"getLocalesData", nullptr, GetLocalesData, nullptr, nullptr, nullptr, napi_default, nullptr},
1506 {"getMediaBase64DataByName", nullptr, GetMediaBase64DataByName, nullptr, nullptr,
1507 nullptr, napi_default, nullptr},
1508 {"getMediaBase64Data", nullptr, GetMediaBase64Data, nullptr, nullptr, nullptr, napi_default, nullptr},
1509 {"getMediaData", nullptr, GetMediaData, nullptr, nullptr, nullptr, napi_default, nullptr},
1510 {"getMediaDataByName", nullptr, GetMediaDataByName, nullptr, nullptr, nullptr, napi_default, nullptr},
1511 {"getDrawableDescriptorData", nullptr, GetDrawableDescriptorData, nullptr,
1512 nullptr, nullptr, napi_default, nullptr},
1513 {"getDrawableDescriptorDataByName", nullptr, GetDrawableDescriptorDataByName, nullptr,
1514 nullptr, nullptr, napi_default, nullptr},
1515 {"addResource", nullptr, AddResource, nullptr, nullptr, nullptr, napi_default, nullptr},
1516 {"removeResource", nullptr, RemoveResource, nullptr, nullptr, nullptr, napi_default, nullptr},
1517 {"getRawFileContentTwo", nullptr, GetRawFileContentTwo, nullptr, nullptr, nullptr, napi_default, nullptr},
1518 {"testGetIntPluralStringById0790_082", nullptr, testGetIntPluralStringById0790_082, nullptr, nullptr,
1519 nullptr, napi_default, nullptr},
1520 {"testGetIntPluralStringByName0790_082", nullptr, testGetIntPluralStringByName0790_082, nullptr, nullptr,
1521 nullptr, napi_default, nullptr},
1522 {"testGetDoublePluralStringById0790_082", nullptr, testGetDoublePluralStringById0790_082, nullptr,
1523 nullptr, nullptr, napi_default, nullptr},
1524 {"testGetDoublePluralStringByName0790_082", nullptr, testGetDoublePluralStringByName0790_082, nullptr,
1525 nullptr, nullptr, napi_default, nullptr},
1526 {"testGetIntPluralStringById119", nullptr, testGetIntPluralStringById119, nullptr, nullptr,
1527 nullptr, napi_default, nullptr},
1528 {"testGetDoublePluralStringById120", nullptr, testGetDoublePluralStringById120, nullptr, nullptr,
1529 nullptr, napi_default, nullptr},
1530 {"testGetIntPluralStringById125", nullptr, testGetIntPluralStringById125, nullptr, nullptr,
1531 nullptr, napi_default, nullptr},
1532 {"testGetDoublePluralStringById126", nullptr, testGetDoublePluralStringById126, nullptr, nullptr,
1533 nullptr, napi_default, nullptr},
1534 {"testGetIntPluralStringById127", nullptr, testGetIntPluralStringById127, nullptr, nullptr,
1535 nullptr, napi_default, nullptr},
1536 {"testGetDoublePluralStringById128", nullptr, testGetDoublePluralStringById128, nullptr, nullptr,
1537 nullptr, napi_default, nullptr},
1538 {"testGetIntPluralStringById129", nullptr, testGetIntPluralStringById129, nullptr, nullptr,
1539 nullptr, napi_default, nullptr},
1540 {"testGetDoublePluralStringById130", nullptr, testGetDoublePluralStringById130, nullptr, nullptr,
1541 nullptr, napi_default, nullptr},
1542 {"testGetIntPluralStringByName133", nullptr, testGetIntPluralStringByName133, nullptr, nullptr,
1543 nullptr, napi_default, nullptr},
1544 {"testGetDoublePluralStringByName134", nullptr, testGetDoublePluralStringByName134, nullptr, nullptr,
1545 nullptr, napi_default, nullptr},
1546 {"testGetIntPluralStringByName139", nullptr, testGetIntPluralStringByName139, nullptr, nullptr,
1547 nullptr, napi_default, nullptr},
1548 {"testGetDoublePluralStringByName140", nullptr, testGetDoublePluralStringByName140, nullptr,
1549 nullptr, nullptr, napi_default, nullptr},
1550 {"testGetIntPluralStringByName141", nullptr, testGetIntPluralStringByName141, nullptr, nullptr,
1551 nullptr, napi_default, nullptr},
1552 {"testGetDoublePluralStringByName142", nullptr, testGetDoublePluralStringByName142, nullptr,
1553 nullptr, nullptr, napi_default, nullptr},
1554 {"getResourceConfiguration", nullptr, GetResourceConfiguration, nullptr,
1555 nullptr, nullptr, napi_default, nullptr},
1556 };
1557
1558 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1559 return exports;
1560 }
1561 EXTERN_C_END
1562
1563 static napi_module demoModule = {
1564 .nm_version = 1,
1565 .nm_flags = 0,
1566 .nm_filename = nullptr,
1567 .nm_register_func = Init,
1568 .nm_modname = "entry",
1569 .nm_priv = ((void *)0),
1570 .reserved = {0},
1571 };
1572
RegisterEntryModule(void)1573 extern "C" __attribute__((constructor)) void RegisterEntryModule(void)
1574 {
1575 napi_module_register(&demoModule);
1576 }