1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "napi/native_api.h"
16 #include "asset_api.h"
17 #include <bits/alltypes.h>
18 #include <cstring>
19
20 static const int MAGIC_RET = 9999;
21 static const int BUFF_MAX = 4096;
22 static const char *DEMO_LABEL = "demo_label";
23
Asset_Add(napi_env env,napi_callback_info info)24 static napi_value Asset_Add(napi_env env, napi_callback_info info)
25 {
26 size_t argc = 2;
27 napi_value args[2] = {nullptr};
28
29 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
30
31 char aliasBuffer[BUFF_MAX];
32 size_t bufferSize = BUFF_MAX;
33 size_t copied = 0;
34
35 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
36
37 char secretBuffer[BUFF_MAX];
38 bufferSize = BUFF_MAX;
39 copied = 0;
40
41 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
42
43 Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
44 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
45
46 Asset_Attr attr[] = {
47 {.tag = ASSET_TAG_ACCESSIBILITY, .value.u32 = ASSET_ACCESSIBILITY_DEVICE_POWERED_ON},
48 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
49 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
50 };
51 int32_t ret = OH_Asset_Add(attr, sizeof(attr) / sizeof(attr[0]));
52 napi_value result;
53 napi_create_uint32(env, ret, &result);
54
55 return result;
56 }
57
58
Asset_Add_Auth(napi_env env,napi_callback_info info)59 static napi_value Asset_Add_Auth(napi_env env, napi_callback_info info)
60 {
61 size_t argc = 2;
62 napi_value args[2] = {nullptr};
63
64 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
65
66 char aliasBuffer[BUFF_MAX];
67 size_t bufferSize = BUFF_MAX;
68 size_t copied = 0;
69
70 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
71
72 char secretBuffer[BUFF_MAX];
73 bufferSize = BUFF_MAX;
74 copied = 0;
75
76 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
77
78 Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
79 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
80 Asset_Blob label = {static_cast<uint32_t>(strlen(DEMO_LABEL)),
81 const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(DEMO_LABEL))};
82 Asset_Attr attr[] = {
83 {.tag = ASSET_TAG_ACCESSIBILITY, .value.u32 = ASSET_ACCESSIBILITY_DEVICE_POWERED_ON},
84 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
85 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
86 {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label},
87 {.tag = ASSET_TAG_AUTH_TYPE, .value.u32 = ASSET_AUTH_TYPE_ANY},
88 };
89 int32_t ret = OH_Asset_Add(attr, sizeof(attr) / sizeof(attr[0]));
90 napi_value result;
91 napi_create_uint32(env, ret, &result);
92
93 return result;
94 }
95
AssetPreAndPostQuerySuccess(Asset_Attr * attr,uint32_t attrCnt)96 static int32_t AssetPreAndPostQuerySuccess(Asset_Attr *attr, uint32_t attrCnt)
97 {
98 uint8_t challengeBuffer[32] = "";
99 Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
100 int32_t result = 0;
101 int32_t ret = OH_Asset_PreQuery(attr, attrCnt, &challenge);
102 if (ret == ASSET_SUCCESS) {
103 Asset_Attr attr2[] = {
104 {.tag = ASSET_TAG_AUTH_CHALLENGE, .value.blob = challenge},
105 };
106 int32_t ret2 = OH_Asset_PostQuery(attr2, sizeof(attr2) / sizeof(attr2[0]));
107 if (ret2 == ASSET_SUCCESS) {
108 result = 1;
109 }
110 OH_Asset_FreeBlob(&challenge);
111 }
112 return result;
113 }
114
AssetPreAndPostQueryNotFound(Asset_Attr * attr,uint32_t attrCnt)115 static int32_t AssetPreAndPostQueryNotFound(Asset_Attr *attr, uint32_t attrCnt)
116 {
117 uint8_t challengeBuffer[32] = "";
118 Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
119 int32_t result = 0;
120 int32_t ret = OH_Asset_PreQuery(attr, attrCnt, &challenge);
121 if (ret == ASSET_NOT_FOUND) {
122 result = 1;
123 }
124 return result;
125 }
126
Asset_PreAndPostQueryNormal(napi_env env,napi_callback_info info)127 static napi_value Asset_PreAndPostQueryNormal(napi_env env, napi_callback_info info)
128 {
129 size_t argc = 2;
130 napi_value args[2] = {nullptr};
131
132 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
133
134 char aliasBuffer[BUFF_MAX];
135 size_t bufferSize = BUFF_MAX;
136 size_t copied = 0;
137
138 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
139
140 char aliasBuffer2[BUFF_MAX];
141 bufferSize = BUFF_MAX;
142 copied = 0;
143
144 napi_get_value_string_utf8(env, args[1], aliasBuffer2, bufferSize, &copied);
145
146 Asset_Blob alias2 = {static_cast<uint32_t>(strlen(aliasBuffer2)), reinterpret_cast<uint8_t *>(aliasBuffer2)};
147 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
148 int32_t result = 0;
149 Asset_Attr attr[] = {
150 {.tag = ASSET_TAG_AUTH_VALIDITY_PERIOD, .value.u32 = 2 * 60},
151 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
152 };
153 result += AssetPreAndPostQuerySuccess(attr, sizeof(attr) / sizeof(attr[0]));
154
155 Asset_Attr attr2[] = {
156 {.tag = ASSET_TAG_ALIAS, .value.blob = alias2},
157 };
158 result += AssetPreAndPostQueryNotFound(attr2, sizeof(attr2) / sizeof(attr2[0]));
159
160 Asset_Attr attr3[] = {};
161 result += AssetPreAndPostQuerySuccess(attr3, sizeof(attr3) / sizeof(attr3[0]));
162
163 napi_value result_real;
164 napi_create_uint32(env, result, &result_real);
165 return result_real;
166 }
167
Asset_PreAndPostQueryError(napi_env env,napi_callback_info info)168 static napi_value Asset_PreAndPostQueryError(napi_env env, napi_callback_info info)
169 {
170 size_t argc = 2;
171 napi_value args[2] = {nullptr};
172
173 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
174
175 char aliasBuffer[BUFF_MAX];
176 size_t bufferSize = BUFF_MAX;
177 size_t copied = 0;
178
179 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
180
181 char secretBuffer[BUFF_MAX];
182 bufferSize = BUFF_MAX;
183 copied = 0;
184
185 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
186
187 Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
188
189 uint8_t challengeBuffer[32] = "";
190 Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
191 Asset_Attr attr[] = {
192 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
193 };
194
195 int32_t ret = OH_Asset_PreQuery(attr, sizeof(attr) / sizeof(attr[0]), &challenge);
196 int32_t result = 0;
197 if (ret == ASSET_INVALID_ARGUMENT) {
198 result += 1;
199 }
200
201 Asset_Attr attr2[] = {
202 {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
203 {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
204 {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
205 };
206
207 ret = OH_Asset_PreQuery(attr2, sizeof(attr2) / sizeof(attr2[0]), &challenge);
208 if (ret == ASSET_INVALID_ARGUMENT) {
209 result += 1;
210 }
211 Asset_Attr attr3[] = {};
212 ret = OH_Asset_PostQuery(attr3, sizeof(attr3) / sizeof(attr3[0]));
213 if (ret == ASSET_INVALID_ARGUMENT) {
214 result += 1;
215 }
216 napi_value result_real;
217 napi_create_uint32(env, result, &result_real);
218 return result_real;
219 }
220
Asset_PreQuery(napi_env env,napi_callback_info info)221 static napi_value Asset_PreQuery(napi_env env, napi_callback_info info)
222 {
223 size_t argc = 1;
224 napi_value args[1] = {nullptr};
225
226 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
227
228 char aliasBuffer[BUFF_MAX];
229 size_t bufferSize = BUFF_MAX;
230 size_t copied = 0;
231
232 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
233
234 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
235 uint8_t challengeBuffer[32] = "";
236 Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
237 Asset_Attr attr[] = {
238 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
239 };
240
241 int32_t ret = OH_Asset_PreQuery(attr, sizeof(attr) / sizeof(attr[0]), &challenge);
242 napi_value result;
243 napi_value tmp;
244 if (ret == ASSET_SUCCESS) {
245 napi_create_string_utf8(env, reinterpret_cast<char *>(challenge.data), challenge.size, &tmp);
246 OH_Asset_FreeBlob(&challenge);
247 if (tmp != NULL) {
248 return tmp;
249 } else {
250 ret = -1;
251 }
252 }
253 napi_create_uint32(env, ret, &result);
254 return result;
255 }
256
Asset_PreAndPostQuery(napi_env env,napi_callback_info info)257 static napi_value Asset_PreAndPostQuery(napi_env env, napi_callback_info info)
258 {
259 size_t argc = 1;
260 napi_value args[1] = {nullptr};
261
262 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
263
264 char aliasBuffer[BUFF_MAX];
265 size_t bufferSize = BUFF_MAX;
266 size_t copied = 0;
267
268 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
269
270 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
271 uint8_t challengeBuffer[32] = "";
272 Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
273 Asset_Attr attr[] = {
274 {.tag = ASSET_TAG_AUTH_VALIDITY_PERIOD, .value.u32 = 2 * 60},
275 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
276 };
277
278 int32_t ret = OH_Asset_PreQuery(attr, sizeof(attr) / sizeof(attr[0]), &challenge);
279 napi_value result;
280 napi_value tmp;
281 if (ret == ASSET_SUCCESS) {
282 napi_create_string_utf8(env, reinterpret_cast<char *>(challenge.data), challenge.size, &tmp);
283 if (tmp != NULL) {
284 Asset_Attr attr2[] = {
285 {.tag = ASSET_TAG_AUTH_CHALLENGE, .value.blob = challenge},
286 };
287 int32_t ret2 = OH_Asset_PostQuery(attr2, sizeof(attr2) / sizeof(attr2[0]));
288 napi_create_uint32(env, ret2, &result);
289 OH_Asset_FreeBlob(&challenge);
290 return result;
291 } else {
292 ret = -1;
293 }
294 }
295
296 napi_create_uint32(env, ret, &result);
297 return result;
298 }
299
Asset_PostQuery(napi_env env,napi_callback_info info)300 static napi_value Asset_PostQuery(napi_env env, napi_callback_info info)
301 {
302 size_t argc = 1;
303 napi_value args[1] = {nullptr};
304
305 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
306
307 char challengeBuffer[BUFF_MAX];
308 size_t bufferSize = BUFF_MAX;
309 size_t copied = 0;
310
311 napi_get_value_string_utf8(env, args[0], challengeBuffer, bufferSize, &copied);
312
313 Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
314 napi_value result;
315 Asset_Attr attr[] = {
316 {.tag = ASSET_TAG_AUTH_CHALLENGE, .value.blob = challenge},
317 };
318 int32_t ret = OH_Asset_PostQuery(attr, sizeof(attr) / sizeof(attr[0]));
319 napi_create_uint32(env, ret, &result);
320 return result;
321 }
322
Asset_RemoveAll(napi_env env,napi_callback_info info)323 static napi_value Asset_RemoveAll(napi_env env, napi_callback_info info)
324 {
325 Asset_Attr attr[] = {
326
327 };
328 int32_t ret = OH_Asset_Remove(attr, sizeof(attr) / sizeof(attr[0]));
329 napi_value result;
330 napi_create_uint32(env, ret, &result);
331 return result;
332 }
333
Asset_Remove(napi_env env,napi_callback_info info)334 static napi_value Asset_Remove(napi_env env, napi_callback_info info)
335 {
336 size_t argc = 1;
337 napi_value args[1] = {nullptr};
338
339 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
340
341 char aliasBuffer[BUFF_MAX];
342 size_t bufferSize = BUFF_MAX;
343 size_t copied = 0;
344
345 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
346 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
347
348 Asset_Attr attr[] = {
349 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
350 };
351 int32_t ret = OH_Asset_Remove(attr, sizeof(attr) / sizeof(attr[0]));
352 napi_value result;
353 napi_create_uint32(env, ret, &result);
354
355 return result;
356 }
357
Asset_RemoveLabel(napi_env env,napi_callback_info info)358 static napi_value Asset_RemoveLabel(napi_env env, napi_callback_info info)
359 {
360 size_t argc = 1;
361 napi_value args[1] = {nullptr};
362
363 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
364
365 char labelBuffer[BUFF_MAX];
366 size_t bufferSize = BUFF_MAX;
367 size_t copied = 0;
368
369 napi_get_value_string_utf8(env, args[0], labelBuffer, bufferSize, &copied);
370 Asset_Blob label = {static_cast<uint32_t>(strlen(labelBuffer)), reinterpret_cast<uint8_t *>(labelBuffer)};
371
372 Asset_Attr attr[] = {
373 {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label},
374 };
375 int32_t ret = OH_Asset_Remove(attr, sizeof(attr) / sizeof(attr[0]));
376 napi_value result;
377 napi_create_uint32(env, ret, &result);
378
379 return result;
380 }
381
AssetRemoveInvalidArg(Asset_Attr * attr,uint32_t attrCnt)382 static int32_t AssetRemoveInvalidArg(Asset_Attr *attr, uint32_t attrCnt)
383 {
384 int32_t result = 0;
385 int32_t ret = OH_Asset_Remove(attr, attrCnt);
386 if (ret == ASSET_INVALID_ARGUMENT) {
387 result = 1;
388 }
389 return result;
390 }
391
Asset_RemoveError(napi_env env,napi_callback_info info)392 static napi_value Asset_RemoveError(napi_env env, napi_callback_info info)
393 {
394 size_t argc = 2;
395 napi_value args[2] = {nullptr};
396
397 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
398
399 char aliasBuffer[BUFF_MAX];
400 size_t bufferSize = BUFF_MAX;
401 size_t copied = 0;
402
403 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
404
405 char secretBuffer[BUFF_MAX];
406 bufferSize = BUFF_MAX;
407 copied = 0;
408
409 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
410
411 Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
412 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
413
414 Asset_Blob label = {static_cast<uint32_t>(strlen(DEMO_LABEL)),
415 const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(DEMO_LABEL))};
416
417 int32_t result = 0;
418 Asset_Attr attr[] = {
419 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
420 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
421 };
422
423 result += AssetRemoveInvalidArg(attr, sizeof(attr) / sizeof(attr[0]));
424
425 Asset_Attr attr2[] = {
426 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
427 };
428
429 result += AssetRemoveInvalidArg(attr2, sizeof(attr2) / sizeof(attr2[0]));
430
431 Asset_Attr attr3[] = {
432 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
433 {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label},
434 };
435 result += AssetRemoveInvalidArg(attr3, sizeof(attr3) / sizeof(attr3[0]));
436
437 Asset_Attr attr4[] = {
438 {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
439 {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
440 {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
441 };
442
443 result += AssetRemoveInvalidArg(attr4, sizeof(attr4) / sizeof(attr4[0]));
444
445 napi_value result_real;
446 napi_create_uint32(env, result, &result_real);
447 return result_real;
448 }
449
Asset_QueryAll(napi_env env,napi_callback_info info)450 static napi_value Asset_QueryAll(napi_env env, napi_callback_info info)
451 {
452 size_t argc = 2;
453 napi_value args[2] = {nullptr};
454
455 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
456
457 char aliasBuffer[BUFF_MAX];
458 size_t bufferSize = BUFF_MAX;
459 size_t copied = 0;
460
461 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
462
463 char secretBuffer[BUFF_MAX];
464 bufferSize = BUFF_MAX;
465 copied = 0;
466
467 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
468 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
469 Asset_Attr attr[] = {
470 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
471 {.tag = ASSET_TAG_RETURN_TYPE, .value.u32 = ASSET_RETURN_ALL},
472 };
473 Asset_ResultSet resultSet = {0};
474 int32_t ret = OH_Asset_Query(attr, sizeof(attr) / sizeof(attr[0]), &resultSet);
475 if (ret == ASSET_SUCCESS) {
476 Asset_Attr *secret = OH_Asset_ParseAttr(resultSet.results + 0, ASSET_TAG_SECRET);
477 if (memcmp(secret->value.blob.data, reinterpret_cast<uint8_t *>(secretBuffer), secret->value.blob.size) == 0) {
478 ret = MAGIC_RET;
479 } else {
480 ret = -1;
481 }
482 } else {
483 ret = -1;
484 }
485 napi_value result;
486 napi_create_uint32(env, ret, &result);
487 OH_Asset_FreeResultSet(&resultSet);
488 return result;
489 }
490
Asset_QueryOption(napi_env env,napi_callback_info info)491 static napi_value Asset_QueryOption(napi_env env, napi_callback_info info)
492 {
493 size_t argc = 4;
494 napi_value args[4] = {nullptr};
495
496 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
497 uint32_t return_limit;
498 napi_get_value_uint32(env, args[0], &return_limit);
499 uint32_t return_offset;
500 napi_get_value_uint32(env, args[1], &return_offset);
501 uint32_t return_ordered_by;
502 napi_get_value_uint32(env, args[2], &return_ordered_by); // 2 is index
503
504 uint32_t value0;
505 napi_get_value_uint32(env, args[3], &value0); // 3 is index
506
507 Asset_Attr attr[] = {
508 {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = return_limit},
509 {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = return_offset},
510 {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = return_ordered_by},
511 };
512 Asset_ResultSet resultSet = {0};
513 int32_t ret = OH_Asset_Query(attr, sizeof(attr) / sizeof(attr[0]), &resultSet);
514 if (ret == ASSET_SUCCESS) {
515 if (resultSet.count == value0) {
516 ret = MAGIC_RET;
517 }
518 }
519 napi_value result;
520 napi_create_uint32(env, ret, &result);
521 OH_Asset_FreeResultSet(&resultSet);
522 return result;
523 }
524
AssetQueryInvalidArg(Asset_Attr * attr,uint32_t attrCnt)525 static int32_t AssetQueryInvalidArg(Asset_Attr *attr, uint32_t attrCnt)
526 {
527 int32_t result = 0;
528 Asset_ResultSet resultSet = {0};
529 int32_t ret = OH_Asset_Query(attr, attrCnt, &resultSet);
530 if (ret == ASSET_INVALID_ARGUMENT) {
531 result = 1;
532 }
533 OH_Asset_FreeResultSet(&resultSet);
534 return result;
535 }
536
Asset_QueryError(napi_env env,napi_callback_info info)537 static napi_value Asset_QueryError(napi_env env, napi_callback_info info)
538 {
539 size_t argc = 2;
540 napi_value args[2] = {nullptr};
541
542 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
543
544 char aliasBuffer[BUFF_MAX];
545 size_t bufferSize = BUFF_MAX;
546 size_t copied = 0;
547
548 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
549
550 char secretBuffer[BUFF_MAX];
551 bufferSize = BUFF_MAX;
552 copied = 0;
553
554 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
555
556 Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
557 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
558 Asset_Blob label = {static_cast<uint32_t>(strlen(DEMO_LABEL)),
559 const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(DEMO_LABEL))};
560
561 Asset_Attr attr[] = {
562 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
563 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
564 };
565 int32_t result = 0;
566 result += AssetQueryInvalidArg(attr, sizeof(attr) / sizeof(attr[0]));
567
568 Asset_Attr attr2[] = {
569 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
570 };
571 result += AssetQueryInvalidArg(attr2, sizeof(attr2) / sizeof(attr2[0]));
572
573 Asset_Attr attr3[] = {
574 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
575 {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label},
576 };
577 result += AssetQueryInvalidArg(attr3, sizeof(attr3) / sizeof(attr3[0]));
578
579 Asset_Attr attr4[] = {
580 {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
581 {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
582 {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
583 };
584 result += AssetQueryInvalidArg(attr4, sizeof(attr4) / sizeof(attr4[0]));
585
586 napi_value result_real;
587 napi_create_uint32(env, result, &result_real);
588 return result_real;
589 }
590
Asset_QueryNum(napi_env env,napi_callback_info info)591 static napi_value Asset_QueryNum(napi_env env, napi_callback_info info)
592 {
593 size_t argc = 1;
594 napi_value args[1] = {nullptr};
595
596 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
597
598 int32_t value0;
599 napi_get_value_int32(env, args[0], &value0);
600
601 Asset_Attr attr[] = {
602
603 };
604 Asset_ResultSet resultSet = {0};
605 int32_t ret = OH_Asset_Query(attr, sizeof(attr) / sizeof(attr[0]), &resultSet);
606 if (ret == ASSET_SUCCESS) {
607 if (resultSet.count == value0) {
608 ret = MAGIC_RET;
609 }
610 }
611 napi_value result;
612 napi_create_uint32(env, ret, &result);
613 OH_Asset_FreeResultSet(&resultSet);
614 return result;
615 }
616
Asset_QueryLabel(napi_env env,napi_callback_info info)617 static napi_value Asset_QueryLabel(napi_env env, napi_callback_info info)
618 {
619 size_t argc = 2;
620 napi_value args[2] = {nullptr};
621
622 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
623
624 char labelBuffer[BUFF_MAX];
625 size_t bufferSize = BUFF_MAX;
626 size_t copied = 0;
627
628 napi_get_value_string_utf8(env, args[0], labelBuffer, bufferSize, &copied);
629
630 int32_t value0;
631 napi_get_value_int32(env, args[1], &value0);
632
633 Asset_Blob label = {static_cast<uint32_t>(strlen(labelBuffer)), reinterpret_cast<uint8_t *>(labelBuffer)};
634
635 Asset_Attr attr[] = {{.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label}};
636 Asset_ResultSet resultSet = {0};
637 int32_t ret = OH_Asset_Query(attr, sizeof(attr) / sizeof(attr[0]), &resultSet);
638 if (ret == ASSET_SUCCESS) {
639 if (resultSet.count == value0) {
640 ret = MAGIC_RET;
641 }
642 }
643 napi_value result;
644 napi_create_uint32(env, ret, &result);
645 OH_Asset_FreeResultSet(&resultSet);
646 return result;
647 }
648
Asset_UpdateEasy(napi_env env,napi_callback_info info)649 static napi_value Asset_UpdateEasy(napi_env env, napi_callback_info info)
650 {
651 size_t argc = 2;
652 napi_value args[2] = {nullptr};
653
654 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
655
656 char aliasBuffer[BUFF_MAX];
657 size_t bufferSize = BUFF_MAX;
658 size_t copied = 0;
659
660 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
661
662 char secretBuffer[BUFF_MAX];
663 bufferSize = BUFF_MAX;
664 copied = 0;
665
666 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
667
668 Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
669 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
670
671 Asset_Attr query[] = {
672 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
673 };
674 Asset_Attr attributesToUpdate[] = {
675 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
676 };
677
678 int32_t ret = OH_Asset_Update(query, sizeof(query) / sizeof(query[0]), attributesToUpdate,
679 sizeof(attributesToUpdate) / sizeof(attributesToUpdate[0]));
680
681 napi_value result;
682 napi_create_uint32(env, ret, &result);
683 return result;
684 }
685
Asset_UpdateLabel(napi_env env,napi_callback_info info)686 static napi_value Asset_UpdateLabel(napi_env env, napi_callback_info info)
687 {
688 size_t argc = 3;
689 napi_value args[3] = {nullptr};
690
691 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
692
693 char aliasBuffer[BUFF_MAX];
694 size_t bufferSize = BUFF_MAX;
695 size_t copied = 0;
696
697 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
698
699 char secretBuffer[BUFF_MAX];
700 bufferSize = BUFF_MAX;
701 copied = 0;
702
703 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
704
705 char labelBuffer[BUFF_MAX];
706 bufferSize = BUFF_MAX;
707 copied = 0;
708
709 napi_get_value_string_utf8(env, args[2], labelBuffer, bufferSize, &copied); // 2 is index
710
711 Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
712 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
713 Asset_Blob label = {static_cast<uint32_t>(strlen(labelBuffer)), reinterpret_cast<uint8_t *>(labelBuffer)};
714
715 Asset_Attr query[] = {
716 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
717 };
718 Asset_Attr attributesToUpdate[] = {{.tag = ASSET_TAG_SECRET, .value.blob = secret},
719 {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label}};
720
721 int32_t ret = OH_Asset_Update(query, sizeof(query) / sizeof(query[0]), attributesToUpdate,
722 sizeof(attributesToUpdate) / sizeof(attributesToUpdate[0]));
723 napi_value result;
724 napi_create_uint32(env, ret, &result);
725 return result;
726 }
727
AssetUpdateInvalidArg(Asset_Attr * query,uint32_t queryCnt,Asset_Attr * attributesToUpdate,uint32_t updateCnt)728 static int32_t AssetUpdateInvalidArg(Asset_Attr *query, uint32_t queryCnt, Asset_Attr *attributesToUpdate,
729 uint32_t updateCnt)
730 {
731 int32_t result = 0;
732 int32_t ret = OH_Asset_Update(query, queryCnt, attributesToUpdate, updateCnt);
733 if (ret == ASSET_INVALID_ARGUMENT) {
734 result = 1;
735 }
736 return result;
737 }
738
Asset_UpdateError(napi_env env,napi_callback_info info)739 static napi_value Asset_UpdateError(napi_env env, napi_callback_info info)
740 {
741 size_t argc = 2;
742 napi_value args[2] = {nullptr};
743
744 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
745
746 char aliasBuffer[BUFF_MAX];
747 size_t bufferSize = BUFF_MAX;
748 size_t copied = 0;
749
750 napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
751
752 char secretBuffer[BUFF_MAX];
753 bufferSize = BUFF_MAX;
754 copied = 0;
755
756 napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
757
758 Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
759 Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
760
761 int32_t result = 0;
762
763 Asset_Attr query[] = {
764 {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
765 };
766 Asset_Attr attributesToUpdate[] = {};
767 result += AssetUpdateInvalidArg(query, sizeof(query) / sizeof(query[0]), attributesToUpdate,
768 sizeof(attributesToUpdate) / sizeof(attributesToUpdate[0]));
769
770 Asset_Attr attributesToUpdate2[] = {
771 {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
772 {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
773 {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
774 };
775 result += AssetUpdateInvalidArg(query, sizeof(query) / sizeof(query[0]), attributesToUpdate2,
776 sizeof(attributesToUpdate2) / sizeof(attributesToUpdate2[0]));
777
778 Asset_Attr query2[] = {};
779 Asset_Attr attributesToUpdate3[] = {
780 {.tag = ASSET_TAG_SECRET, .value.blob = secret},
781 };
782 result += AssetUpdateInvalidArg(query2, sizeof(query2) / sizeof(query2[0]), attributesToUpdate3,
783 sizeof(attributesToUpdate3) / sizeof(attributesToUpdate3[0]));
784
785 Asset_Attr query3[] = {
786 {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
787 {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
788 {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
789 };
790 result += AssetUpdateInvalidArg(query3, sizeof(query3) / sizeof(query3[0]), attributesToUpdate3,
791 sizeof(attributesToUpdate3) / sizeof(attributesToUpdate3[0]));
792
793 napi_value result_real;
794 napi_create_uint32(env, result, &result_real);
795 return result_real;
796 }
797
798 EXTERN_C_START
Init(napi_env env,napi_value exports)799 static napi_value Init(napi_env env, napi_value exports)
800 {
801 napi_property_descriptor desc[] = {
802 {"asset_add", nullptr, Asset_Add, nullptr, nullptr, nullptr, napi_default, nullptr},
803 {"asset_queryNum", nullptr, Asset_QueryNum, nullptr, nullptr, nullptr, napi_default, nullptr},
804 {"asset_queryAll", nullptr, Asset_QueryAll, nullptr, nullptr, nullptr, napi_default, nullptr},
805 {"asset_removeAll", nullptr, Asset_RemoveAll, nullptr, nullptr, nullptr, napi_default, nullptr},
806 {"asset_remove", nullptr, Asset_Remove, nullptr, nullptr, nullptr, napi_default, nullptr},
807 {"asset_removeLabel", nullptr, Asset_RemoveLabel, nullptr, nullptr, nullptr, napi_default, nullptr},
808 {"asset_removeError", nullptr, Asset_RemoveError, nullptr, nullptr, nullptr, napi_default, nullptr},
809 {"asset_queryLabel", nullptr, Asset_QueryLabel, nullptr, nullptr, nullptr, napi_default, nullptr},
810 {"asset_queryOption", nullptr, Asset_QueryOption, nullptr, nullptr, nullptr, napi_default, nullptr},
811 {"asset_queryError", nullptr, Asset_QueryError, nullptr, nullptr, nullptr, napi_default, nullptr},
812 {"asset_updateEasy", nullptr, Asset_UpdateEasy, nullptr, nullptr, nullptr, napi_default, nullptr},
813 {"asset_updateLabel", nullptr, Asset_UpdateLabel, nullptr, nullptr, nullptr, napi_default, nullptr},
814 {"asset_updateError", nullptr, Asset_UpdateError, nullptr, nullptr, nullptr, napi_default, nullptr},
815 {"asset_preAndPostQueryNormal", nullptr, Asset_PreAndPostQueryNormal, nullptr, nullptr, nullptr, napi_default,
816 nullptr},
817 {"asset_preAndPostQueryError", nullptr, Asset_PreAndPostQueryError, nullptr, nullptr, nullptr, napi_default,
818 nullptr},
819 {"asset_addAuth", nullptr, Asset_Add_Auth, nullptr, nullptr, nullptr, napi_default, nullptr},
820 {"asset_preQuery", nullptr, Asset_PreQuery, nullptr, nullptr, nullptr, napi_default, nullptr},
821 {"asset_preAndPostQuery", nullptr, Asset_PreAndPostQuery, nullptr, nullptr, nullptr, napi_default, nullptr},
822 {"asset_postQuery", nullptr, Asset_PostQuery, nullptr, nullptr, nullptr, napi_default, nullptr},
823
824 };
825 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
826 return exports;
827 }
828 EXTERN_C_END
829
830 /*
831 * module define
832 */
833 static napi_module g_module = {.nm_version = 1,
834 .nm_flags = 0,
835 .nm_filename = nullptr,
836 .nm_register_func = Init,
837 .nm_modname = "assetNdkTest",
838 .nm_priv = ((void *)0),
839 .reserved = {0}};
840
841 /*
842 * module register
843 */
MyPixelMapRegisterModule(void)844 extern "C" __attribute__((constructor)) void MyPixelMapRegisterModule(void) { napi_module_register(&g_module); }
845