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 "js_storage.h"
17 
18 static std::map<std::string, std::string> g_keyValueStorage;
19 
20 using namespace StorageBufferSize;
21 
Add(napi_env env, napi_value handler)22 void EventListener::Add(napi_env env, napi_value handler)
23 {
24     if (Find(env, handler) != nullptr) {
25         return;
26     }
27 
28     if (handlers_ == nullptr) {
29         handlers_ = new EventHandler();
30         handlers_->next = nullptr;
31     } else {
32         auto temp = new EventHandler();
33         temp->next = handlers_;
34         handlers_ = temp;
35     }
36     napi_create_reference(env, handler, 1, &handlers_->callbackRef);
37 }
38 
Del(napi_env env, napi_value handler)39 void EventListener::Del(napi_env env, napi_value handler)
40 {
41     EventHandler* temp = nullptr;
42     for (EventHandler* i = handlers_; i != nullptr; i = handlers_) {
43         napi_value callback = nullptr;
44         napi_get_reference_value(env, i->callbackRef, &callback);
45         bool isEquals = false;
46         napi_strict_equals(env, handler, callback, &isEquals);
47         if (isEquals) {
48             if (temp == nullptr) {
49                 handlers_ = i->next;
50             } else {
51                 temp->next = i->next;
52             }
53             napi_delete_reference(env, i->callbackRef);
54             delete i;
55         } else {
56             temp = i;
57         }
58     }
59 }
60 
Clear(napi_env env)61 void EventListener::Clear(napi_env env)
62 {
63     for (EventHandler* i = handlers_; i != nullptr; i = handlers_) {
64         handlers_ = i->next;
65         delete i;
66     }
67 }
68 
Find(napi_env env, napi_value handler)69 EventHandler* EventListener::Find(napi_env env, napi_value handler)
70 {
71     EventHandler* result = nullptr;
72     for (EventHandler* i = handlers_; i != nullptr; i = i->next) {
73         napi_value callback = nullptr;
74         napi_get_reference_value(env, i->callbackRef, &callback);
75         bool isEquals = false;
76         napi_strict_equals(env, handler, callback, &isEquals);
77         if (isEquals) {
78             result = i;
79         }
80     }
81     return result;
82 }
83 
StorageObjectInfo(napi_env env)84 StorageObjectInfo::StorageObjectInfo(napi_env env) : env_(env), listeners_()
85 {
86     listeners_[STORAGE_EVENT_CHANGE].type_ = "change";
87     listeners_[STORAGE_EVENT_CLEAR].type_ = "clear";
88     listeners_[STORAGE_EVENT_ERROR].type_ = "error";
89 }
90 
~StorageObjectInfo()91 StorageObjectInfo::~StorageObjectInfo()
92 {
93     listeners_[STORAGE_EVENT_CHANGE].Clear(env_);
94     listeners_[STORAGE_EVENT_CLEAR].Clear(env_);
95     listeners_[STORAGE_EVENT_ERROR].Clear(env_);
96 }
97 
On(const char* type, napi_value handler)98 void StorageObjectInfo::On(const char* type, napi_value handler)
99 {
100     StorageEvent event = Find(type);
101     if (event == STORAGE_EVENT_UNKNOWN) {
102         return;
103     }
104     listeners_[event].Add(env_, handler);
105 }
106 
Off(const char* type, napi_value handler)107 void StorageObjectInfo::Off(const char* type, napi_value handler)
108 {
109     StorageEvent event = Find(type);
110     if (event == STORAGE_EVENT_UNKNOWN) {
111         return;
112     }
113     if (handler == nullptr) {
114         listeners_[event].Clear(env_);
115     } else {
116         listeners_[event].Del(env_, handler);
117     }
118 }
119 
Emit(napi_value thisArg, const char* type)120 void StorageObjectInfo::Emit(napi_value thisArg, const char* type)
121 {
122     StorageEvent event = Find(type);
123     if (event == STORAGE_EVENT_UNKNOWN) {
124         return;
125     }
126     for (EventHandler* handler = listeners_[event].handlers_; handler != nullptr; handler = handler->next) {
127         if (thisArg == nullptr) {
128             napi_get_undefined(env_, &thisArg);
129         }
130         napi_value callback = nullptr;
131         napi_value result = nullptr;
132         napi_get_reference_value(env_, handler->callbackRef, &callback);
133         napi_call_function(env_, thisArg, callback, 0, nullptr, &result);
134     }
135 }
136 
Find(const char* type) const137 StorageEvent StorageObjectInfo::Find(const char* type) const
138 {
139     StorageEvent result = STORAGE_EVENT_UNKNOWN;
140     if (!strcmp(listeners_[STORAGE_EVENT_CHANGE].type_, type)) {
141         result = STORAGE_EVENT_CHANGE;
142     } else if (!strcmp(listeners_[STORAGE_EVENT_CLEAR].type_, type)) {
143         result = STORAGE_EVENT_CLEAR;
144     } else if (!strcmp(listeners_[STORAGE_EVENT_ERROR].type_, type)) {
145         result = STORAGE_EVENT_ERROR;
146     }
147     return result;
148 }
149 
GetParameOfGet(napi_env env, size_t argc, napi_value* argv, StorageAsyncContext* asyncContext)150 bool GetParameOfGet(napi_env env, size_t argc, napi_value* argv, StorageAsyncContext* asyncContext)
151 {
152     for (size_t i = 0; i < argc; i++) {
153         napi_valuetype valueType = napi_undefined;
154         napi_typeof(env, argv[i], &valueType);
155         if ((i == 0) && (valueType == napi_string)) {
156             napi_get_value_string_utf8(env, argv[i], asyncContext->key, KEY_BUFFER_SIZE, &asyncContext->keyLen);
157         } else if (valueType == napi_string) {
158             napi_get_value_string_utf8(env, argv[i], asyncContext->value, VALUE_BUFFER_SIZE, &asyncContext->valueLen);
159         } else if (valueType == napi_function) {
160             napi_create_reference(env, argv[i], 1, &asyncContext->callbackRef);
161             break;
162         } else {
163             return false;
164         }
165     }
166     return true;
167 }
168 
JSStorageGetParameterFromArg(napi_env env, size_t argc, napi_value* argv, StorageAsyncContext* asyncContext, GetParaType paraType)169 bool JSStorageGetParameterFromArg(napi_env env,
170                                   size_t argc,
171                                   napi_value* argv,
172                                   StorageAsyncContext* asyncContext,
173                                   GetParaType paraType)
174 {
175     if (paraType == GetParaType::GET) {
176         return GetParameOfGet(env, argc, argv, asyncContext);
177     }
178     for (size_t i = FIRST_ARG; i < argc; i++) {
179         napi_valuetype valueType = napi_undefined;
180         napi_typeof(env, argv[i], &valueType);
181 
182         if (i == FIRST_ARG) {
183             if (paraType == GetParaType::CLEAR && valueType == napi_function) {
184                 napi_create_reference(env, argv[i], 1, &asyncContext->callbackRef);
185                 return true;
186             } else if (valueType == napi_string) {
187                 napi_get_value_string_utf8(env, argv[i], asyncContext->key, KEY_BUFFER_SIZE, &asyncContext->keyLen);
188                 continue;
189             }
190             return false;
191         } else if (i == SECOND_ARG) {
192             if (paraType == GetParaType::DELETE && valueType == napi_function) {
193                 napi_create_reference(env, argv[i], 1, &asyncContext->callbackRef);
194                 return true;
195             } else if (valueType == napi_string) {
196                 napi_get_value_string_utf8(env, argv[i], asyncContext->value, VALUE_BUFFER_SIZE,
197                                            &asyncContext->valueLen);
198                 continue;
199             }
200             return false;
201         } else if (i == THIRD_ARG && valueType == napi_function) {
202             napi_create_reference(env, argv[i], 1, &asyncContext->callbackRef);
203         } else {
204             return false;
205         }
206     }
207     return true;
208 }
209 
CreateAsyncWorkOfGet(napi_env env, StorageAsyncContext* asyncContext, napi_value resource, napi_value result)210 void CreateAsyncWorkOfGet(napi_env env, StorageAsyncContext* asyncContext, napi_value resource, napi_value result)
211 {
212     napi_create_async_work(
213         env, nullptr, resource,
214         [](napi_env env, void* data) {
215             StorageAsyncContext* asyncContext = (StorageAsyncContext*)data;
216             auto itr = g_keyValueStorage.find(asyncContext->key);
217             if (itr != g_keyValueStorage.end()) {
218                 if (strncpy_s(asyncContext->value, VALUE_BUFFER_SIZE, itr->second.c_str(), itr->second.length()) !=
219                     EOK) {
220                     asyncContext->status = 1;
221                 } else {
222                     asyncContext->status = 0;
223                 }
224             } else {
225                 asyncContext->status = 1;
226             }
227         },
228         [](napi_env env, napi_status status, void* data) {
229             StorageAsyncContext* asyncContext = (StorageAsyncContext*)data;
230             napi_value result[2] = { 0 };
231             if (!asyncContext->status) {
232                 napi_get_undefined(env, &result[0]);
233                 napi_create_string_utf8(env, asyncContext->value, strlen(asyncContext->value), &result[1]);
234             } else {
235                 napi_value message = nullptr;
236                 napi_create_string_utf8(env, "key does not exist", NAPI_AUTO_LENGTH, &message);
237                 napi_create_error(env, nullptr, message, &result[0]);
238                 napi_get_undefined(env, &result[1]);
239                 asyncContext->objectInfo->Emit(nullptr, "error");
240             }
241             if (asyncContext->deferred) {
242                 if (!asyncContext->status) {
243                     napi_resolve_deferred(env, asyncContext->deferred, result[1]);
244                 } else {
245                     napi_reject_deferred(env, asyncContext->deferred, result[0]);
246                 }
247             } else {
248                 napi_value callback = nullptr;
249                 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
250                 napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[0]), result, nullptr);
251                 napi_delete_reference(env, asyncContext->callbackRef);
252             }
253             napi_delete_async_work(env, asyncContext->work);
254             delete asyncContext;
255         },
256         (void*)asyncContext, &asyncContext->work);
257     napi_queue_async_work(env, asyncContext->work);
258 }
259 
CreateAsyncWorkOfSet(napi_env env, StorageAsyncContext* asyncContext, napi_value resource, napi_value result)260 void CreateAsyncWorkOfSet(napi_env env, StorageAsyncContext* asyncContext, napi_value resource, napi_value result)
261 {
262     napi_create_async_work(
263         env, nullptr, resource,
264         [](napi_env env, void* data) {
265             StorageAsyncContext* asyncContext = (StorageAsyncContext*)data;
266             auto itr = g_keyValueStorage.find(asyncContext->key);
267             if (itr == g_keyValueStorage.end()) {
268                 g_keyValueStorage.insert(std::pair<std::string, std::string>(asyncContext->key, asyncContext->value));
269                 asyncContext->status = 0;
270             } else {
271                 asyncContext->status = 1;
272             }
273         },
274         [](napi_env env, napi_status status, void* data) {
275             StorageAsyncContext* asyncContext = (StorageAsyncContext*)data;
276             napi_value result[2] = { 0 };
277             if (!asyncContext->status) {
278                 napi_get_undefined(env, &result[0]);
279                 napi_get_undefined(env, &result[1]);
280                 asyncContext->objectInfo->Emit(nullptr, "change");
281             } else {
282                 napi_value message = nullptr;
283                 napi_create_string_utf8(env, "key already exists", NAPI_AUTO_LENGTH, &message);
284                 napi_create_error(env, nullptr, message, &result[0]);
285                 napi_get_undefined(env, &result[1]);
286                 asyncContext->objectInfo->Emit(nullptr, "error");
287             }
288 
289             if (asyncContext->deferred) {
290                 if (!asyncContext->status) {
291                     napi_resolve_deferred(env, asyncContext->deferred, result[1]);
292                 } else {
293                     napi_reject_deferred(env, asyncContext->deferred, result[0]);
294                 }
295             } else {
296                 napi_value callback = nullptr;
297                 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
298                 napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[0]), result, nullptr);
299                 napi_delete_reference(env, asyncContext->callbackRef);
300             }
301             napi_delete_async_work(env, asyncContext->work);
302             delete asyncContext;
303         },
304         (void*)asyncContext, &asyncContext->work);
305     napi_queue_async_work(env, asyncContext->work);
306 }
307 
CreateAsyncWorkOfDelete(napi_env env, StorageAsyncContext* asyncContext, napi_value resource, napi_value result)308 void CreateAsyncWorkOfDelete(napi_env env, StorageAsyncContext* asyncContext, napi_value resource, napi_value result)
309 {
310     napi_create_async_work(
311         env, nullptr, resource,
312         [](napi_env env, void* data) {
313             StorageAsyncContext* asyncContext = (StorageAsyncContext*)data;
314             auto itr = g_keyValueStorage.find(asyncContext->key);
315             if (itr != g_keyValueStorage.end()) {
316                 g_keyValueStorage.erase(itr);
317                 asyncContext->status = 0;
318             } else {
319                 asyncContext->status = 1;
320             }
321         },
322         [](napi_env env, napi_status status, void* data) {
323             StorageAsyncContext* asyncContext = (StorageAsyncContext*)data;
324             napi_value result[2] = { 0 };
325             if (!asyncContext->status) {
326                 napi_get_undefined(env, &result[0]);
327                 napi_get_undefined(env, &result[1]);
328                 asyncContext->objectInfo->Emit(nullptr, "change");
329             } else {
330                 napi_value message = nullptr;
331                 napi_create_string_utf8(env, "key does not exist", NAPI_AUTO_LENGTH, &message);
332                 napi_create_error(env, nullptr, message, &result[0]);
333                 napi_get_undefined(env, &result[1]);
334                 asyncContext->objectInfo->Emit(nullptr, "error");
335             }
336 
337             if (asyncContext->deferred) {
338                 if (!asyncContext->status) {
339                     napi_resolve_deferred(env, asyncContext->deferred, result[1]);
340                 } else {
341                     napi_reject_deferred(env, asyncContext->deferred, result[0]);
342                 }
343             } else {
344                 napi_value callback = nullptr;
345                 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
346                 napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[0]), result, nullptr);
347                 napi_delete_reference(env, asyncContext->callbackRef);
348             }
349             napi_delete_async_work(env, asyncContext->work);
350             delete asyncContext;
351         },
352         (void*)asyncContext, &asyncContext->work);
353     napi_queue_async_work(env, asyncContext->work);
354 }
355 
CreateAsyncWorkOfClear(napi_env env, StorageAsyncContext* asyncContext, napi_value resource, napi_value result)356 void CreateAsyncWorkOfClear(napi_env env, StorageAsyncContext* asyncContext, napi_value resource, napi_value result)
357 {
358     napi_create_async_work(
359         env, nullptr, resource,
360         [](napi_env env, void* data) {
361             StorageAsyncContext* asyncContext = (StorageAsyncContext*)data;
362             auto itr = g_keyValueStorage.find(asyncContext->key);
363             if (itr != g_keyValueStorage.end()) {
364                 g_keyValueStorage.erase(itr);
365                 asyncContext->status = 0;
366             } else {
367                 asyncContext->status = 1;
368             }
369         },
370         [](napi_env env, napi_status status, void* data) {
371             StorageAsyncContext* asyncContext = (StorageAsyncContext*)data;
372             napi_value result[2] = { 0 };
373             if (!asyncContext->status) {
374                 napi_get_undefined(env, &result[0]);
375                 napi_get_undefined(env, &result[1]);
376                 asyncContext->objectInfo->Emit(nullptr, "change");
377             } else {
378                 napi_value message = nullptr;
379                 napi_create_string_utf8(env, "key does not exist", NAPI_AUTO_LENGTH, &message);
380                 napi_create_error(env, nullptr, message, &result[0]);
381                 napi_get_undefined(env, &result[1]);
382                 asyncContext->objectInfo->Emit(nullptr, "error");
383             }
384 
385             if (asyncContext->deferred) {
386                 if (!asyncContext->status) {
387                     napi_resolve_deferred(env, asyncContext->deferred, result[1]);
388                 } else {
389                     napi_reject_deferred(env, asyncContext->deferred, result[0]);
390                 }
391             } else {
392                 napi_value callback = nullptr;
393                 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
394                 napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[0]), result, nullptr);
395                 napi_delete_reference(env, asyncContext->callbackRef);
396             }
397             napi_delete_async_work(env, asyncContext->work);
398             delete asyncContext;
399         },
400         (void*)asyncContext, &asyncContext->work);
401     napi_queue_async_work(env, asyncContext->work);
402 }
403 
JSStorageConstructor(napi_env env, napi_callback_info info)404 static napi_value JSStorageConstructor(napi_env env, napi_callback_info info)
405 {
406     napi_value thisVar = nullptr;
407     void* data = nullptr;
408     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
409 
410     auto objectInfo = new StorageObjectInfo(env);
411     napi_wrap(
412         env, thisVar, objectInfo,
413         [](napi_env env, void* data, void* hint) {
414             auto objectInfo = (StorageObjectInfo*)data;
415             if (objectInfo != nullptr) {
416                 delete objectInfo;
417             }
418         },
419         nullptr, nullptr);
420 
421     return thisVar;
422 }
423 
424 /***********************************************
425  * Async Function Set
426  ***********************************************/
427 
428 // storage.get(key: string, defaultValue?: string, callback?: Function): void | Promise<string>
JSStorageGet(napi_env env, napi_callback_info info)429 static napi_value JSStorageGet(napi_env env, napi_callback_info info)
430 {
431     size_t requireArgc = 1;
432     size_t argc = 3;
433     napi_value argv[3] = { 0 };
434     napi_value thisVar = nullptr;
435     void* data = nullptr;
436     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
437 
438     NAPI_ASSERT(env, argc >= requireArgc, "requires 1 parameter");
439 
440     auto asyncContext = new StorageAsyncContext();
441 
442     asyncContext->env = env;
443 
444     if (!JSStorageGetParameterFromArg(env, argc, argv, asyncContext, GetParaType::GET)) {
445         NAPI_ASSERT(env, false, "type mismatch");
446     }
447 
448     napi_value result = nullptr;
449 
450     if (asyncContext->callbackRef == nullptr) {
451         napi_create_promise(env, &asyncContext->deferred, &result);
452     } else {
453         napi_get_undefined(env, &result);
454     }
455 
456     napi_unwrap(env, thisVar, (void**)&asyncContext->objectInfo);
457 
458     napi_value resource = nullptr;
459     napi_create_string_utf8(env, "JSStorageGet", NAPI_AUTO_LENGTH, &resource);
460 
461     CreateAsyncWorkOfGet(env, asyncContext, resource, result);
462 
463     return result;
464 }
465 
466 // storage.set(key: string, value: string, callback?: Function): void | Promise<void>
JSStorageSet(napi_env env, napi_callback_info info)467 static napi_value JSStorageSet(napi_env env, napi_callback_info info)
468 {
469     size_t requireArgc = 2;
470     size_t argc = 3;
471     napi_value argv[3] = { 0 };
472     napi_value thisVar = nullptr;
473     void* data = nullptr;
474     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
475 
476     NAPI_ASSERT(env, argc >= requireArgc, "requires 2 parameters");
477     auto asyncContext = new StorageAsyncContext();
478     asyncContext->env = env;
479 
480     if (!JSStorageGetParameterFromArg(env, argc, argv, asyncContext, GetParaType::SET)) {
481         NAPI_ASSERT(env, false, "type mismatch");
482     }
483 
484     napi_value result = nullptr;
485 
486     if (asyncContext->callbackRef == nullptr) {
487         napi_create_promise(env, &asyncContext->deferred, &result);
488     } else {
489         napi_get_undefined(env, &result);
490     }
491 
492     napi_unwrap(env, thisVar, (void**)&asyncContext->objectInfo);
493 
494     napi_value resource = nullptr;
495     napi_create_string_utf8(env, "JStorageSet", NAPI_AUTO_LENGTH, &resource);
496 
497     CreateAsyncWorkOfSet(env, asyncContext, resource, result);
498 
499     return result;
500 }
501 
502 // storage.delete(key: string, callback?: Function): void | Promise<void>
JSStorageDelete(napi_env env, napi_callback_info info)503 static napi_value JSStorageDelete(napi_env env, napi_callback_info info)
504 {
505     size_t requireArgc = 1;
506     size_t argc = 2;
507     napi_value argv[2] = { 0 };
508     napi_value thisVar = nullptr;
509     void* data = nullptr;
510     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
511 
512     NAPI_ASSERT(env, argc >= requireArgc, "requires 1 parameter");
513 
514     auto asyncContext = new StorageAsyncContext();
515 
516     asyncContext->env = env;
517 
518     if (!JSStorageGetParameterFromArg(env, argc, argv, asyncContext, GetParaType::DELETE)) {
519         NAPI_ASSERT(env, false, "type mismatch");
520     }
521 
522     napi_value result = nullptr;
523 
524     if (asyncContext->callbackRef == nullptr) {
525         napi_create_promise(env, &asyncContext->deferred, &result);
526     } else {
527         napi_get_undefined(env, &result);
528     }
529 
530     napi_unwrap(env, thisVar, (void**)&asyncContext->objectInfo);
531 
532     napi_value resource = nullptr;
533     napi_create_string_utf8(env, "JSStorageDelete", NAPI_AUTO_LENGTH, &resource);
534 
535     CreateAsyncWorkOfDelete(env, asyncContext, resource, result);
536 
537     return result;
538 }
539 
540 // storage.clear(callback?: Function): void | Promise<void>
JSStorageClear(napi_env env, napi_callback_info info)541 static napi_value JSStorageClear(napi_env env, napi_callback_info info)
542 {
543     size_t argc = 1;
544     napi_value argv[1] = { 0 };
545     napi_value thisVar = nullptr;
546     void* data = nullptr;
547     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
548 
549     auto asyncContext = new StorageAsyncContext();
550 
551     asyncContext->env = env;
552 
553     if (!JSStorageGetParameterFromArg(env, argc, argv, asyncContext, GetParaType::CLEAR)) {
554         NAPI_ASSERT(env, false, "type mismatch");
555     }
556 
557     napi_value result = nullptr;
558 
559     if (asyncContext->callbackRef == nullptr) {
560         napi_create_promise(env, &asyncContext->deferred, &result);
561     } else {
562         napi_get_undefined(env, &result);
563     }
564 
565     napi_unwrap(env, thisVar, (void**)&asyncContext->objectInfo);
566 
567     napi_value resource = nullptr;
568     napi_create_string_utf8(env, "JSStorageClear", NAPI_AUTO_LENGTH, &resource);
569 
570     CreateAsyncWorkOfClear(env, asyncContext, resource, result);
571 
572     return result;
573 }
574 
575 /***********************************************
576  * Sync Function Set
577  ***********************************************/
578 // storage.getSync(key: string, defaultValue?: string): string
JSStorageGetSync(napi_env env, napi_callback_info info)579 static napi_value JSStorageGetSync(napi_env env, napi_callback_info info)
580 {
581     size_t requireArgc = 1;
582     size_t argc = 2;
583     napi_value argv[2] = { 0 };
584     napi_value thisVar = nullptr;
585     void* data = nullptr;
586     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
587 
588     NAPI_ASSERT(env, argc >= requireArgc, "requires 1 parameter");
589 
590     char key[KEY_BUFFER_SIZE] = { 0 };
591     size_t keyLen = 0;
592     char value[VALUE_BUFFER_SIZE] = { 0 };
593     size_t valueLen = 0;
594     for (size_t i = 0; i < argc; i++) {
595         napi_valuetype valueType = napi_undefined;
596         napi_typeof(env, argv[i], &valueType);
597 
598         if (i == FIRST_ARG && valueType == napi_string) {
599             napi_get_value_string_utf8(env, argv[i], key, KEY_BUFFER_SIZE, &keyLen);
600         } else if (i == SECOND_ARG && valueType == napi_string) {
601             napi_get_value_string_utf8(env, argv[i], value, VALUE_BUFFER_SIZE, &valueLen);
602             break;
603         } else {
604             NAPI_ASSERT(env, false, "type mismatch");
605         }
606     }
607     StorageObjectInfo* objectInfo = nullptr;
608     napi_unwrap(env, thisVar, (void**)&objectInfo);
609     auto itr = g_keyValueStorage.find(key);
610     napi_value result = nullptr;
611     if (itr != g_keyValueStorage.end()) {
612         napi_create_string_utf8(env, itr->second.c_str(), itr->second.length(), &result);
613     } else if (valueLen > 0) {
614         napi_create_string_utf8(env, value, valueLen, &result);
615     } else {
616         objectInfo->Emit(nullptr, "error");
617         NAPI_ASSERT(env, false, "key does not exist");
618     }
619     return result;
620 }
621 
622 // storage.setSync(key: string, value: string): void
JSStorageSetSync(napi_env env, napi_callback_info info)623 static napi_value JSStorageSetSync(napi_env env, napi_callback_info info)
624 {
625     size_t requireArgc = 2;
626     size_t argc = 2;
627     napi_value argv[2] = { 0 };
628     napi_value thisVar = nullptr;
629     void* data = nullptr;
630     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
631 
632     NAPI_ASSERT(env, argc >= requireArgc, "requires 2 parameters");
633 
634     char key[KEY_BUFFER_SIZE] = { 0 };
635     size_t keyLen = 0;
636     char value[VALUE_BUFFER_SIZE] = { 0 };
637     size_t valueLen = 0;
638     for (size_t i = 0; i < argc; i++) {
639         napi_valuetype valueType = napi_undefined;
640         napi_typeof(env, argv[i], &valueType);
641 
642         if (i == FIRST_ARG && valueType == napi_string) {
643             napi_get_value_string_utf8(env, argv[i], key, KEY_BUFFER_SIZE, &keyLen);
644         } else if (i == SECOND_ARG && valueType == napi_string) {
645             napi_get_value_string_utf8(env, argv[i], value, VALUE_BUFFER_SIZE, &valueLen);
646             break;
647         } else {
648             NAPI_ASSERT(env, false, "type mismatch");
649         }
650     }
651     StorageObjectInfo* objectInfo = nullptr;
652     napi_unwrap(env, thisVar, (void**)&objectInfo);
653     auto itr = g_keyValueStorage.find(key);
654     if (itr == g_keyValueStorage.end()) {
655         g_keyValueStorage.insert(std::pair<std::string, std::string>(key, value));
656         objectInfo->Emit(nullptr, "change");
657     } else {
658         objectInfo->Emit(nullptr, "error");
659         NAPI_ASSERT(env, false, "key already exists");
660     }
661     napi_value result = nullptr;
662     napi_get_undefined(env, &result);
663     return result;
664 }
665 
666 // storage.deleteSync(key: string): void
JSStorageDeleteSync(napi_env env, napi_callback_info info)667 static napi_value JSStorageDeleteSync(napi_env env, napi_callback_info info)
668 {
669     size_t requireArgc = 1;
670     size_t argc = 2;
671     napi_value argv[2] = { 0 };
672     napi_value thisVar = nullptr;
673     void* data = nullptr;
674     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
675 
676     NAPI_ASSERT(env, argc >= requireArgc, "requires 1 parameter");
677 
678     char key[KEY_BUFFER_SIZE] = { 0 };
679     size_t keyLen = 0;
680 
681     napi_valuetype keyType = napi_undefined;
682     napi_typeof(env, argv[0], &keyType);
683     NAPI_ASSERT(env, keyType == napi_string, "type mismatch");
684     napi_get_value_string_utf8(env, argv[0], key, KEY_BUFFER_SIZE, &keyLen);
685 
686     StorageObjectInfo* objectInfo = nullptr;
687     napi_unwrap(env, thisVar, (void**)&objectInfo);
688 
689     auto itr = g_keyValueStorage.find(key);
690     if (itr != g_keyValueStorage.end()) {
691         g_keyValueStorage.erase(itr);
692         objectInfo->Emit(nullptr, "change");
693     } else {
694         objectInfo->Emit(nullptr, "error");
695         NAPI_ASSERT(env, itr != g_keyValueStorage.end(), "key does not exist");
696     }
697 
698     napi_value result = nullptr;
699     napi_get_undefined(env, &result);
700     return result;
701 }
702 
703 // storage.clearSync(): void
JSStorageClearSync(napi_env env, napi_callback_info info)704 static napi_value JSStorageClearSync(napi_env env, napi_callback_info info)
705 {
706     napi_value thisVar = nullptr;
707     void* data = nullptr;
708     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
709 
710     StorageObjectInfo* objectInfo = nullptr;
711     napi_unwrap(env, thisVar, (void**)&objectInfo);
712     g_keyValueStorage.clear();
713     objectInfo->Emit(nullptr, "clear");
714     napi_value result = nullptr;
715     napi_get_undefined(env, &result);
716     return result;
717 }
718 
719 /***********************************************
720  * Event Function Set
721  ***********************************************/
722 // storage.on(event: "change" | "clear", callback: Function): void
JSStorageOn(napi_env env, napi_callback_info info)723 static napi_value JSStorageOn(napi_env env, napi_callback_info info)
724 {
725     size_t requireArgc = 2;
726     size_t argc = 2;
727     napi_value argv[2] = { 0 };
728     napi_value thisVar = nullptr;
729     void* data = nullptr;
730     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
731 
732     NAPI_ASSERT(env, argc >= requireArgc, "requires 2 parameters");
733 
734     char eventType[EVENT_TYPE_SIZE] = { 0 };
735     size_t eventTypeLen = 0;
736     napi_valuetype eventValueType = napi_undefined;
737     napi_typeof(env, argv[0], &eventValueType);
738     NAPI_ASSERT(env, eventValueType == napi_string, "parameter 1 type mismatch");
739     napi_get_value_string_utf8(env, argv[0], eventType, EVENT_TYPE_SIZE, &eventTypeLen);
740 
741     napi_valuetype callbackType = napi_undefined;
742     napi_typeof(env, argv[1], &callbackType);
743     NAPI_ASSERT(env, callbackType == napi_function, "parameter 2 type mismatch");
744 
745     StorageObjectInfo* objectInfo = nullptr;
746     napi_unwrap(env, thisVar, (void**)&objectInfo);
747 
748     objectInfo->On(eventType, argv[1]);
749 
750     napi_value result = nullptr;
751     napi_get_undefined(env, &result);
752     return result;
753 }
754 
755 // storage.off(event: "change" | "clear", callback?: Function): void
JSStorageOff(napi_env env, napi_callback_info info)756 static napi_value JSStorageOff(napi_env env, napi_callback_info info)
757 {
758     size_t requireArgc = 1;
759     size_t argc = 2;
760     napi_value argv[2] = { 0 };
761     napi_value thisVar = nullptr;
762     void* data = nullptr;
763     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
764 
765     NAPI_ASSERT(env, argc >= requireArgc, "requires 1 parameter");
766 
767     char eventType[EVENT_TYPE_SIZE] = { 0 };
768     size_t eventTypeLen = 0;
769     napi_valuetype eventValueType = napi_undefined;
770     napi_typeof(env, argv[0], &eventValueType);
771     NAPI_ASSERT(env, eventValueType == napi_string, "parameter 1 type mismatch");
772     napi_get_value_string_utf8(env, argv[0], eventType, EVENT_TYPE_SIZE, &eventTypeLen);
773 
774     StorageObjectInfo* objectInfo = nullptr;
775     napi_unwrap(env, thisVar, (void**)&objectInfo);
776 
777     if (argc > requireArgc) {
778         napi_valuetype callbackType = napi_undefined;
779         napi_typeof(env, argv[1], &callbackType);
780         NAPI_ASSERT(env, callbackType == napi_function, "parameter 2 type mismatch");
781         objectInfo->Off(eventType, argv[1]);
782     } else {
783         objectInfo->Off(eventType);
784     }
785 
786     napi_value result = nullptr;
787     napi_get_undefined(env, &result);
788     return result;
789 }
790 
791 /***********************************************
792  * Module export and register
793  ***********************************************/
StorageExport(napi_env env, napi_value exports)794 static napi_value StorageExport(napi_env env, napi_value exports)
795 {
796     const char* storageClassName = "Storage";
797     napi_value storageClass = nullptr;
798     static napi_property_descriptor storageDesc[] = {
799         DECLARE_NAPI_FUNCTION("get", JSStorageGet),
800         DECLARE_NAPI_FUNCTION("set", JSStorageSet),
801         DECLARE_NAPI_FUNCTION("delete", JSStorageDelete),
802         DECLARE_NAPI_FUNCTION("clear", JSStorageClear),
803         DECLARE_NAPI_FUNCTION("getSync", JSStorageGetSync),
804         DECLARE_NAPI_FUNCTION("setSync", JSStorageSetSync),
805         DECLARE_NAPI_FUNCTION("deleteSync", JSStorageDeleteSync),
806         DECLARE_NAPI_FUNCTION("clearSync", JSStorageClearSync),
807         DECLARE_NAPI_FUNCTION("on", JSStorageOn),
808         DECLARE_NAPI_FUNCTION("off", JSStorageOff),
809     };
810     napi_define_class(env, storageClassName, strlen(storageClassName), JSStorageConstructor, nullptr,
811                       sizeof(storageDesc) / sizeof(storageDesc[0]), storageDesc, &storageClass);
812 
813     static napi_property_descriptor desc[] = {
814         DECLARE_NAPI_PROPERTY("Storage", storageClass),
815     };
816 
817     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
818     return exports;
819 }
820 
821 // storage module define
822 static napi_module storageModule = {
823     .nm_version = 1,
824     .nm_flags = 0,
825     .nm_filename = nullptr,
826     .nm_register_func = StorageExport,
827     .nm_modname = "storage",
828     .nm_priv = ((void*)0),
829     .reserved = { 0 },
830 };
831 
832 // storage module register
StorageRegister()833 extern "C" __attribute__((constructor)) void StorageRegister()
834 {
835     napi_module_register(&storageModule);
836 }
837