• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "napi_settings.h"
17 #include "napi_settings_observer.h"
18 
19 #include <pthread.h>
20 #include <unistd.h>
21 
22 #include "abs_shared_result_set.h"
23 #include "napi_settings_log.h"
24 #include "values_bucket.h"
25 
26 #include "napi_base_context.h"
27 #include "os_account_manager.h"
28 
29 
30 using namespace OHOS::AppExecFwk;
31 using namespace OHOS::DataShare;
32 using namespace OHOS::AccountSA;
33 
34 namespace OHOS {
35 namespace Settings {
36 const std::string SETTINGS_DATA_BASE_URI = "dataability:///com.ohos.settingsdata.DataAbility";
37 const std::string SETTINGS_DATA_FIELD_KEYWORD = "KEYWORD";
38 const std::string SETTINGS_DATA_FIELD_VALUE = "VALUE";
39 const int DB_HELPER_TRIAL_NUMBER = 2;
40 const int USERID_HELPER_NUMBER = 100;
41 
42 /**
43  * @brief Wrap void to js value.
44  * ability_context
45  * @param env the environment that the Node-API call is invoked under
46  * @return napi_value napi_value after wrapped
47  */
wrap_void_to_js(napi_env env)48 napi_value wrap_void_to_js(napi_env env)
49 {
50     napi_value result = nullptr;
51     NAPI_CALL(env, napi_get_null(env, &result));
52     return result;
53 }
54 
55 /**
56  * @brief Unwrap string from js value.
57  *
58  * @param env the environment that the Node-API call is invoked under
59  * @param param js value to unwrap
60  * @return std::string string value after unwrapped
61  */
unwrap_string_from_js(napi_env env,napi_value param)62 std::string unwrap_string_from_js(napi_env env, napi_value param)
63 {
64     std::string defaultValue("");
65 
66     size_t size = 0;
67     if (napi_get_value_string_utf8(env, param, nullptr, 0, &size) != napi_ok) {
68         return defaultValue;
69     }
70 
71     if (size == 0) {
72         return defaultValue;
73     }
74 
75     std::string value("");
76 
77     char *buf = new (std::nothrow) char[size + 1];
78     if (buf == nullptr) {
79         SETTING_LOG_INFO("unwarp");
80         return value;
81     }
82     memset_s(buf, size + 1, 0, size + 1);
83 
84     bool rev = napi_get_value_string_utf8(env, param, buf, size + 1, &size) == napi_ok;
85     if (rev) {
86         value = buf;
87     } else {
88         value = defaultValue;
89     }
90 
91     delete[] buf;
92     buf = nullptr;
93     SETTING_LOG_INFO("unwarp str is : %{public}s", value.c_str());
94     return value;
95 }
96 
97 /**
98  * @brief Wrap string to js value.
99  *
100  * @param env the environment that the Node-API call is invoked under
101  * @param value string value to be wrap
102  * @return napi_value js value after wrapped
103  */
wrap_string_to_js(napi_env env,const std::string & value)104 napi_value wrap_string_to_js(napi_env env, const std::string &value)
105 {
106     napi_value result = nullptr;
107     NAPI_CALL(env, napi_create_string_utf8(env, value.c_str(), NAPI_AUTO_LENGTH, &result));
108     return result;
109 }
110 
111 /**
112  * @brief Wrap bool to js value.
113  *
114  * @param env the environment that the Node-API call is invoked under
115  * @param value bool value to be wrap
116  * @return napi_value js value after wrapped
117  */
wrap_bool_to_js(napi_env env,bool value)118 napi_value wrap_bool_to_js(napi_env env, bool value)
119 {
120     napi_value result = nullptr;
121     NAPI_CALL(env, napi_get_boolean(env, value, &result));
122     return result;
123 }
124 
125 /**
126  * @brief getUri NAPI implementation.
127  *
128  * @param env the environment that the Node-API call is invoked under
129  * @param info the callback info passed into the callback function
130  * @return napi_value the return value from NAPI C++ to JS for the module.
131  */
napi_get_uri_sync(napi_env env,napi_callback_info info)132 napi_value napi_get_uri_sync(napi_env env, napi_callback_info info)
133 {
134     SETTING_LOG_INFO("called");
135 
136     napi_value retUri = nullptr;
137 
138     // Check the number of the arguments
139     size_t argc = ARGS_TWO;
140     napi_value args[ARGS_TWO] = {nullptr};
141     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
142     if (argc != ARGS_ONE && argc != ARGS_TWO) {
143         SETTING_LOG_ERROR("%{public}s, wrong number of arguments.", __func__);
144         return wrap_void_to_js(env);
145     }
146 
147     // Check the value type of the arguments
148     napi_valuetype valueType;
149     NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valueType));
150     NAPI_ASSERT(env, valueType == napi_string, "Wrong argument type. String expected.");
151 
152     if (argc == ARGS_TWO) {
153         SETTING_LOG_INFO("ARGS_TWO");
154         std::string keyStr = unwrap_string_from_js(env, args[PARAM0]);
155         // get userId string
156         std::vector<int> tmpId;
157         OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(tmpId);
158         std::string tmpIdStr = "100";
159         if (tmpId.size() > 0) {
160             tmpIdStr = std::to_string(tmpId[0]);
161         } else {
162             SETTING_LOG_ERROR("userid is invalid, use id 100 instead");
163         }
164         std::string tableName = unwrap_string_from_js(env, args[PARAM1]);
165         std::string retStr = GetStageUriStr(tableName, tmpIdStr, keyStr);
166         retUri = wrap_string_to_js(env, retStr);
167         return retUri;
168     } else {
169         SETTING_LOG_INFO("ARGS_OTHER (should one)");
170         NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
171         if (argc != ARGS_ONE) {
172             SETTING_LOG_ERROR("%{public}s, wrong number of arguments.", __func__);
173             return wrap_void_to_js(env);
174         }
175 
176         std::string uriArgStr = unwrap_string_from_js(env, args[PARAM0]);
177         uriArgStr = "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=" + uriArgStr;
178         retUri = wrap_string_to_js(env, uriArgStr);
179         return retUri;
180     }
181 }
182 
napi_get_uri(napi_env env,napi_callback_info info)183 napi_value napi_get_uri(napi_env env, napi_callback_info info)
184 {
185     SETTING_LOG_INFO("uri called");
186     // Check the number of the arguments
187     size_t argc = ARGS_THREE;
188     napi_value args[ARGS_THREE] = {nullptr};
189     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
190     if (argc != ARGS_ONE && argc != ARGS_TWO && argc != ARGS_THREE) {
191         SETTING_LOG_ERROR(
192             "uri %{public}s, wrong number of arguments, expect 1 or 2 or 3 but get %{public}zd",
193             __func__,
194             argc);
195         return wrap_void_to_js(env);
196     }
197 
198     // Check the value type of the arguments
199     napi_valuetype valueType;
200     NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valueType));
201     NAPI_ASSERT(env, valueType == napi_string, "uri Wrong argument type. String expected.");
202 
203     // check call type for stage model
204     CallType callType = INVALID_CALL;
205     if (argc == ARGS_ONE) {
206         callType = STAGE_PROMISE;
207     } else if (argc == ARGS_TWO) {
208         napi_valuetype valueType;
209         NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valueType));
210         if (valueType == napi_string) {
211             callType = STAGE_PROMISE_SPECIFIC;
212         } else {
213             callType = STAGE_CALLBACK;
214         }
215     } else if (argc == ARGS_THREE) {
216         callType = STAGE_CALLBACK_SPECIFIC;
217     }
218 
219     SETTING_LOG_INFO("uri arg count is %{public}zd", argc);
220     AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo {
221         .env = env,
222         .asyncWork = nullptr,
223         .deferred = nullptr,
224         .callbackRef = nullptr,
225         .dataAbilityHelper = nullptr,
226         .key = "",
227         .value = "",
228         .uri = "",
229         .status = false,
230     };
231 
232     std::string keyStr = unwrap_string_from_js(env, args[PARAM0]);
233     // get userId string
234     std::vector<int> tmpId;
235     OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(tmpId);
236     std::string tmpIdStr = "100";
237     if (tmpId.size() > 0) {
238         tmpIdStr = std::to_string(tmpId[0]);
239     } else {
240         SETTING_LOG_ERROR("userid is invalid, use id 100 instead");
241     }
242     std::string tableName = "";
243     if (callType == STAGE_CALLBACK_SPECIFIC) {
244         tableName = unwrap_string_from_js(env, args[PARAM2]);
245     } else if (callType == STAGE_PROMISE_SPECIFIC) {
246         tableName = unwrap_string_from_js(env, args[PARAM1]);
247     } else {
248         tableName = "global";
249     }
250     std::string retStr = GetStageUriStr(tableName, tmpIdStr, keyStr);
251     asyncCallbackInfo->uri = retStr;
252     SETTING_LOG_INFO("uri aft is %{public}s", asyncCallbackInfo->uri.c_str());
253 
254     napi_value resource = nullptr;
255     NAPI_CALL(env, napi_create_string_utf8(env, "getUri", NAPI_AUTO_LENGTH, &resource));
256 
257     if (callType == STAGE_CALLBACK || callType == STAGE_CALLBACK_SPECIFIC) {
258         SETTING_LOG_INFO("uri do c_b");
259         napi_create_reference(env, args[PARAM1], 1, &asyncCallbackInfo->callbackRef);
260 
261         napi_create_async_work(
262             env,
263             nullptr,
264             resource,
265             [](napi_env env, void* data) {
266                 SETTING_LOG_INFO("uri c_b asy execute c_b");
267             },
268             [](napi_env env, napi_status status, void* data) {
269                 if (data == nullptr) {
270                     SETTING_LOG_INFO("uri c_b asy end data is null");
271                     return;
272                 }
273                 SETTING_LOG_INFO("uri c_b asy end");
274                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
275                 napi_value undefine;
276                 napi_get_undefined(env, &undefine);
277                 napi_value callback = nullptr;
278                 napi_value result = wrap_string_to_js(env, asyncCallbackInfo->uri);
279                 napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
280                 napi_call_function(env, nullptr, callback, 1, &result, &undefine);
281                 napi_delete_reference(env, asyncCallbackInfo->callbackRef);
282                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
283                 delete asyncCallbackInfo;
284                 SETTING_LOG_INFO("uri c_b change complete");
285             },
286             (void*)asyncCallbackInfo,
287             &asyncCallbackInfo->asyncWork
288         );
289 
290         SETTING_LOG_INFO("uri c_b start asy work");
291         NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
292         SETTING_LOG_INFO("uri c_b end asy work");
293         return wrap_void_to_js(env);
294     } else {
295         SETTING_LOG_INFO("uri do p_m");
296         napi_value promise;
297         napi_deferred deferred;
298         NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
299         asyncCallbackInfo->deferred = deferred;
300 
301         napi_create_async_work(
302             env,
303             nullptr,
304             resource,
305             // aysnc executed task
306             [](napi_env env, void* data) {
307                 SETTING_LOG_INFO("uri p_m asy execute c_b");
308             },
309             // async end called callback+
310             [](napi_env env, napi_status status, void* data) {
311                 SETTING_LOG_INFO("uri p_m asy end");
312                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
313                 SETTING_LOG_INFO("uri p_m end get c_b value is %{public}s",
314                     asyncCallbackInfo->uri.c_str());
315                 napi_value result = wrap_string_to_js(env, asyncCallbackInfo->uri);
316                 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
317                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
318                 delete asyncCallbackInfo;
319             },
320             (void*)asyncCallbackInfo,
321             &asyncCallbackInfo->asyncWork);
322         napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
323         SETTING_LOG_INFO("uri p_m end asy work");
324         return promise;
325     }
326 }
327 
getDataShareHelper(napi_env env,const napi_value context,const bool stageMode,std::string tableName)328 std::shared_ptr<DataShareHelper> getDataShareHelper(
329     napi_env env, const napi_value context, const bool stageMode, std::string tableName)
330 {
331     std::shared_ptr<OHOS::DataShare::DataShareHelper> dataShareHelper = nullptr;
332     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultset = nullptr;
333     std::vector<int> tmpId;
334     OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(tmpId);
335     std::string tmpIdStr = "100";
336     if (tmpId.size() > 0) {
337         tmpIdStr = std::to_string(tmpId[0]);
338     } else {
339         SETTING_LOG_ERROR("userid is invalid, use id 100 instead");
340     }
341     std::string strUri = "datashare:///com.ohos.settingsdata.DataAbility";
342     std::string strProxyUri = GetProxyUriStr(tableName, tmpIdStr);
343     OHOS::Uri proxyUri(strProxyUri);
344     SETTING_LOG_INFO("<Ver-11-14> strProxyUri: %{public}s", strProxyUri.c_str());
345     auto contextS = OHOS::AbilityRuntime::GetStageModeContext(env, context);
346 
347     dataShareHelper = OHOS::DataShare::DataShareHelper::Creator(contextS->GetToken(), strProxyUri);
348     SETTING_LOG_INFO("g_D_S_H Creator<strProxyUri> called");
349 
350     DataSharePredicates predicates;
351     predicates.Limit(1, 0);
352     std::vector<std::string> columns;
353     if (dataShareHelper == nullptr) {
354         SETTING_LOG_INFO(
355             "g_D_S_H d_S_H = nullptr, strUri %{public}s", strUri.c_str());
356         dataShareHelper = OHOS::DataShare::DataShareHelper::Creator(contextS->GetToken(), strUri);
357         return dataShareHelper;
358     }
359 
360     resultset = dataShareHelper->Query(proxyUri, predicates, columns);
361     int numRows = 0;
362     if (resultset != nullptr) {
363         resultset->GetRowCount(numRows);
364     }
365     SETTING_LOG_INFO("numRows %{public}d", numRows);
366     if (resultset == nullptr || numRows <= 0) {
367         int trial = 0;
368         do {
369             SETTING_LOG_INFO("settingsnapi : getDataShareHelper resultset == nullptr, strUri %{public}s %{public}d",
370                 strUri.c_str(),
371                 trial);
372             dataShareHelper = OHOS::DataShare::DataShareHelper::Creator(contextS->GetToken(), strUri);
373         } while (trial++ < DB_HELPER_TRIAL_NUMBER && dataShareHelper == nullptr);
374         return dataShareHelper;
375     }
376     resultset->Close();
377     return dataShareHelper;
378 }
379 
GetValueExecuteExt(napi_env env,void * data)380 void GetValueExecuteExt(napi_env env, void *data)
381 {
382     if (data == nullptr) {
383         SETTING_LOG_INFO("execute data is null");
384         return;
385     }
386 
387     SETTING_LOG_INFO("G_V_E_E start");
388     AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
389 
390     std::vector<std::string> columns;
391     columns.push_back(SETTINGS_DATA_FIELD_VALUE);
392 
393     OHOS::DataShare::DataSharePredicates predicates;
394     predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, asyncCallbackInfo->key);
395 
396     std::vector<int> tmpId;
397     OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(tmpId);
398     std::string tmpIdStr = "100";
399     if (tmpId.size() > 0) {
400         tmpIdStr = std::to_string(tmpId[0]);
401     } else {
402         SETTING_LOG_ERROR("userid is invalid, use id 100 instead");
403     }
404     std::string strUri = GetStageUriStr(asyncCallbackInfo->tableName, tmpIdStr, asyncCallbackInfo->key);
405     SETTING_LOG_INFO(
406         "Get uri : %{public}s, key: %{public}s", strUri.c_str(), (asyncCallbackInfo->key).c_str());
407     OHOS::Uri uri(strUri);
408 
409     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultset = nullptr;
410     if (asyncCallbackInfo->dataShareHelper != nullptr) {
411         SETTING_LOG_INFO("a_C_B_I->d_S_H != nullptr");
412         resultset = asyncCallbackInfo->dataShareHelper->Query(uri, predicates, columns);
413     }
414     int numRows = 0;
415     if (resultset != nullptr) {
416         SETTING_LOG_INFO("G_V_E_E resultset is NOT empty");
417         resultset->GetRowCount(numRows);
418     }
419 
420     SETTING_LOG_INFO("numRows %{public}d", numRows);
421     if (resultset == nullptr || numRows <= 0) {
422         SETTING_LOG_INFO("G_V_E_E return error");
423         asyncCallbackInfo->status = -1;
424     } else {
425         std::string val;
426         int32_t columnIndex = 0;
427         resultset->GoToFirstRow();
428         resultset->GetString(columnIndex, val);
429 
430         SETTING_LOG_INFO("n_g_v_e %{public}s", val.c_str());
431         asyncCallbackInfo->value = val;
432         asyncCallbackInfo->status = napi_ok;
433     }
434 
435     if (resultset != nullptr) {
436         resultset->Close();
437     }
438 }
439 
DeleteCallbackInfo(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)440 void DeleteCallbackInfo(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
441 {
442     if (env != nullptr) {
443         napi_delete_reference(env, asyncCallbackInfo->callbackRef);
444         napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
445     }
446     asyncCallbackInfo->dataShareHelper = nullptr;
447     delete asyncCallbackInfo;
448 }
449 
CompleteCall(napi_env env,napi_status status,void * data,const napi_value retVaule)450 void CompleteCall(napi_env env, napi_status status, void *data, const napi_value retVaule)
451 {
452     AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
453     napi_value result[PARAM2] = {0};
454     if (status == napi_ok && asyncCallbackInfo->status == napi_ok) {
455         napi_get_undefined(env, &result[PARAM0]);
456         result[PARAM1] = retVaule;
457     } else {
458         napi_value message = nullptr;
459         napi_create_string_utf8(env, "async call failed", NAPI_AUTO_LENGTH, &message);
460         napi_create_error(env, nullptr, message, &result[PARAM0]);
461         napi_get_undefined(env, &result[PARAM1]);
462     }
463     napi_value callback = nullptr;
464     napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
465     napi_value returnValue;
466     napi_call_function(env, nullptr, callback, PARAM2, result, &returnValue);
467     DeleteCallbackInfo(env, asyncCallbackInfo);
468     SETTING_LOG_INFO("c_b complete");
469 }
470 
CompletePromise(napi_env env,napi_status status,void * data,const napi_value retVaule)471 void CompletePromise(napi_env env, napi_status status, void *data, const napi_value retVaule)
472 {
473     SETTING_LOG_INFO("p_m asy end  c_b");
474     AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
475     napi_value result = nullptr;
476     if (status == napi_ok && asyncCallbackInfo->status == napi_ok) {
477         napi_resolve_deferred(env, asyncCallbackInfo->deferred, retVaule);
478     } else {
479         napi_get_undefined(env, &result);
480         napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
481     }
482     DeleteCallbackInfo(env, asyncCallbackInfo);
483 }
484 
SetValueExecuteExt(napi_env env,void * data,const std::string setValue)485 void SetValueExecuteExt(napi_env env, void *data, const std::string setValue)
486 {
487     if (data == nullptr) {
488         SETTING_LOG_INFO("s_V_E_E data is null");
489         return;
490     }
491     SETTING_LOG_INFO("execute start");
492     AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
493 
494     OHOS::DataShare::DataShareValuesBucket val;
495     val.Put(SETTINGS_DATA_FIELD_KEYWORD, asyncCallbackInfo->key);
496     val.Put(SETTINGS_DATA_FIELD_VALUE, setValue);
497 
498     std::vector<int> tmpId;
499     OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(tmpId);
500     std::string tmpIdStr = "100";
501     if (tmpId.size() > 0) {
502         tmpIdStr = std::to_string(tmpId[0]);
503     } else {
504         SETTING_LOG_ERROR("userid is invalid, use id 100 instead");
505     }
506     std::string strUri = GetStageUriStr(asyncCallbackInfo->tableName, tmpIdStr, asyncCallbackInfo->key);
507     SETTING_LOG_INFO(
508         "Set uri : %{public}s, key: %{public}s", strUri.c_str(), (asyncCallbackInfo->key).c_str());
509     OHOS::Uri uri(strUri);
510 
511     OHOS::DataShare::DataSharePredicates predicates;
512     predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, asyncCallbackInfo->key);
513 
514     int retInt = 0;
515     if (asyncCallbackInfo->status == -1) {
516         if (asyncCallbackInfo->dataShareHelper != nullptr) {
517             retInt = asyncCallbackInfo->dataShareHelper->Insert(uri, val);
518             SETTING_LOG_INFO("aft in status: %{public}d", retInt);
519         }
520         SETTING_LOG_INFO("n_s_v_e aft in");
521     } else {
522         if (asyncCallbackInfo->dataShareHelper != nullptr) {
523             retInt = asyncCallbackInfo->dataShareHelper->Update(uri, predicates, val);
524             SETTING_LOG_INFO("aft up status: %{public}d", retInt);
525         }
526         SETTING_LOG_INFO("n_s_v_e aft Up");
527     }
528     asyncCallbackInfo->status = retInt;
529 }
530 
531 /**
532  * @brief getValue NAPI implementation.
533  *
534  * @param env the environment that the Node-API call is invoked under
535  * @param info the callback info passed into the callback function
536  * @return napi_value the return value from NAPI C++ to JS for the module.
537  */
napi_get_value_sync(napi_env env,napi_callback_info info)538 napi_value napi_get_value_sync(napi_env env, napi_callback_info info)
539 {
540     SETTING_LOG_INFO("n_g_v");
541 
542     // Check the number of the arguments
543     size_t argc = ARGS_FOUR;
544     napi_value args[ARGS_FOUR] = {nullptr};
545     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
546     if (argc != ARGS_THREE && argc != ARGS_FOUR) {
547         SETTING_LOG_ERROR("%{public}s, wrong number of arguments.", __func__);
548         return wrap_void_to_js(env);
549     }
550 
551     // Check the value type of the arguments
552     napi_valuetype valueType;
553     NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valueType));
554     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument[0] type. Object expected.");
555     NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valueType));
556     NAPI_ASSERT(env, valueType == napi_string, "Wrong argument[1] type. String expected.");
557     NAPI_CALL(env, napi_typeof(env, args[PARAM2], &valueType));
558     NAPI_ASSERT(env, valueType == napi_string, "Wrong argument[2] type. String expected.");
559 
560     bool stageMode = false;
561     napi_status status = OHOS::AbilityRuntime::IsStageContext(env, args[PARAM0], stageMode);
562     if (status == napi_ok) {
563         return napi_get_value_sync_ext(stageMode, argc, env, args);
564     }
565 
566     std::shared_ptr<Uri> uri = std::make_shared<Uri>(SETTINGS_DATA_BASE_URI);
567     std::shared_ptr<DataAbilityHelper> dataAbilityHelper = nullptr;
568     NAPIDataAbilityHelperWrapper* wrapper = nullptr;
569     NAPI_CALL(env, napi_unwrap(env, args[PARAM0], reinterpret_cast<void **>(&wrapper)));
570     if (wrapper != nullptr) {
571         dataAbilityHelper = wrapper->GetDataAbilityHelper();
572     }
573 
574     std::vector<std::string> columns;
575     columns.push_back(SETTINGS_DATA_FIELD_VALUE);
576     OHOS::NativeRdb::DataAbilityPredicates predicates;
577     predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, unwrap_string_from_js(env, args[PARAM1]));
578 
579     SETTING_LOG_INFO("n_g_v bef d_A_H->Query");
580     std::shared_ptr<OHOS::NativeRdb::AbsSharedResultSet> resultset = nullptr;
581     if (dataAbilityHelper != nullptr) {
582         resultset = dataAbilityHelper->Query(*uri, columns, predicates);
583     };
584 
585     napi_value retVal = nullptr;
586     int numRows = 0;
587 
588     if (resultset != nullptr) {
589         SETTING_LOG_INFO("n_g_v resultset is NOT empty");
590         resultset->GetRowCount(numRows);
591     }
592 
593     if (resultset == nullptr || numRows == 0) {
594         SETTING_LOG_INFO("n_g_v return def value");
595         retVal = args[PARAM2];
596     } else {
597         SETTING_LOG_INFO("n_g_v return value from resultset");
598         std::string val;
599         int32_t columnIndex = 0;
600         resultset->GoToFirstRow();
601         resultset->GetString(columnIndex, val);
602         retVal = wrap_string_to_js(env, val);
603     }
604 
605     if (resultset != nullptr) {
606         resultset->Close();
607     }
608     dataAbilityHelper = nullptr;
609     SETTING_LOG_INFO("n_g_v END!");
610     return retVal;
611 }
612 
get_val_CB_exe_CB(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)613 void get_val_CB_exe_CB(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
614 {
615     std::vector<std::string> columns;
616     columns.push_back(SETTINGS_DATA_FIELD_VALUE);
617     OHOS::NativeRdb::DataAbilityPredicates predicates;
618     predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, asyncCallbackInfo->key);
619 
620     std::shared_ptr<Uri> uri = std::make_shared<Uri>(SETTINGS_DATA_BASE_URI);
621     std::shared_ptr<OHOS::NativeRdb::AbsSharedResultSet> resultset = nullptr;
622     if (asyncCallbackInfo->dataAbilityHelper != nullptr) {
623         resultset = asyncCallbackInfo->dataAbilityHelper->Query(*uri, columns, predicates);
624     };
625     SETTING_LOG_INFO("c_b n_g_v aft d_A_H->Query");
626 
627     int numRows = 0;
628     if (resultset != nullptr) {
629         SETTING_LOG_INFO("c_b n_g_v resultset is NOT empty");
630         resultset->GetRowCount(numRows);
631     }
632     if (resultset == nullptr || numRows == 0) {
633         SETTING_LOG_INFO("c_b n_g_v return def value");
634     } else {
635         std::string val;
636         int32_t columnIndex = 0;
637         resultset->GoToFirstRow();
638         resultset->GetString(columnIndex, val);
639         SETTING_LOG_INFO("c_b retVal is %{public}s", val.c_str());
640         asyncCallbackInfo->value = val;
641     }
642     if (resultset != nullptr) {
643         resultset->Close();
644     }
645 }
646 
napi_get_value(napi_env env,napi_callback_info info)647 napi_value napi_get_value(napi_env env, napi_callback_info info)
648 {
649     // getValue api need 3 parameters when Promise mode and need 4 parameters when callback mode
650     const size_t paramOfCallback = ARGS_THREE;
651 
652     size_t argc = ARGS_FOUR;
653     napi_value args[ARGS_FOUR] = {nullptr};
654     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
655     if (argc != ARGS_TWO && argc != ARGS_THREE && argc != ARGS_FOUR) {
656         SETTING_LOG_ERROR(
657             "%{public}s, wrong number of arguments, expect 2 or 3 or 4 but get %{public}zd",
658             __func__,
659             argc);
660         return wrap_void_to_js(env);
661     }
662 
663     SETTING_LOG_INFO("n_g_v arg count is %{public}zd", argc);
664     AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo {
665         .env = env,
666         .asyncWork = nullptr,
667         .deferred = nullptr,
668         .callbackRef = nullptr,
669         .dataAbilityHelper = nullptr,
670         .key = "",
671         .value = "",
672         .uri = "",
673         .status = false,
674     };
675     // Check the value type of the arguments
676     napi_valuetype valueType;
677     NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valueType));
678     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument[0] type. Object expected.");
679     NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valueType));
680     NAPI_ASSERT(env, valueType == napi_string, "Wrong argument[1], type. String expected");
681 
682     bool stageMode = false;
683     napi_status status = OHOS::AbilityRuntime::IsStageContext(env, args[PARAM0], stageMode);
684     if (status == napi_ok) {
685         SETTING_LOG_INFO("argv[0] is a context, Stage Model: %{public}d", stageMode);
686         return napi_get_value_ext(env, info, stageMode);
687     }
688 
689     NAPIDataAbilityHelperWrapper* wrapper = nullptr;
690     NAPI_CALL(env, napi_unwrap(env, args[PARAM0], reinterpret_cast<void **>(&wrapper)));
691     if (wrapper != nullptr) {
692         asyncCallbackInfo->dataAbilityHelper = wrapper->GetDataAbilityHelper();
693     }
694 
695     asyncCallbackInfo->key = unwrap_string_from_js(env, args[PARAM1]);
696     SETTING_LOG_INFO("input param is : (key %{public}s", asyncCallbackInfo->key.c_str());
697 
698     napi_value resource = nullptr;
699     NAPI_CALL(env, napi_create_string_utf8(env, "getValue", NAPI_AUTO_LENGTH, &resource));
700 
701     if (argc == paramOfCallback) {
702         SETTING_LOG_INFO("do c_b");
703 
704         napi_create_reference(env, args[PARAM2], 1, &asyncCallbackInfo->callbackRef);
705 
706         napi_create_async_work(
707             env,
708             nullptr,
709             resource,
710             // aysnc executed task
711             [](napi_env env, void *data) {
712                 if (data == nullptr) {
713                     SETTING_LOG_INFO("c_b async execute data is null");
714                     return;
715                 }
716                 SETTING_LOG_INFO("c_b async execute c_b");
717                 AsyncCallbackInfo *asyncCallbackInfo = (AsyncCallbackInfo *)data;
718                 get_val_CB_exe_CB(env, asyncCallbackInfo);
719             },
720             // async end called callback
721             [](napi_env env, napi_status status, void *data) {
722                 if (data == nullptr) {
723                     SETTING_LOG_INFO("c_b end data is null");
724                     return;
725                 }
726                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
727                 napi_value undefine;
728                 napi_get_undefined(env, &undefine);
729                 napi_value callback = nullptr;
730                 napi_value result = wrap_string_to_js(env, asyncCallbackInfo->value);
731                 napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
732                 napi_call_function(env, nullptr, callback, 1, &result, &undefine);
733                 napi_delete_reference(env, asyncCallbackInfo->callbackRef);
734                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
735                 asyncCallbackInfo->dataAbilityHelper = nullptr;
736                 delete asyncCallbackInfo;
737                 SETTING_LOG_INFO("c_b change complete");
738             },
739             (void *)asyncCallbackInfo,
740             &asyncCallbackInfo->asyncWork);
741 
742         NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
743         SETTING_LOG_INFO("c_b end async work");
744         return wrap_void_to_js(env);
745     } else {
746         SETTING_LOG_INFO("do p_m");
747         napi_value promise;
748         napi_deferred deferred;
749         NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
750         asyncCallbackInfo->deferred = deferred;
751 
752         napi_create_async_work(
753         env,
754         nullptr,
755         resource,
756         // aysnc executed task
757         [](napi_env env, void* data) {
758             AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
759             SETTING_LOG_INFO("p_m get c_b key is %{public}s, value is: %{public}s",
760 			    asyncCallbackInfo->key.c_str(), asyncCallbackInfo->value.c_str());
761 
762             std::vector<std::string> columns;
763             columns.push_back(SETTINGS_DATA_FIELD_VALUE);
764             OHOS::NativeRdb::DataAbilityPredicates predicates;
765             predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, asyncCallbackInfo->key);
766 
767             std::shared_ptr<Uri> uri = std::make_shared<Uri>(SETTINGS_DATA_BASE_URI);
768             std::shared_ptr<OHOS::NativeRdb::AbsSharedResultSet> resultset = nullptr;
769             if (asyncCallbackInfo->dataAbilityHelper != nullptr) {
770                 resultset = asyncCallbackInfo->dataAbilityHelper->Query(*uri, columns, predicates);
771             }
772             SETTING_LOG_INFO("p_m n_g_v aft d_A_H->Query");
773 
774             int numRows = 0;
775             if (resultset != nullptr) {
776                 SETTING_LOG_INFO("p_m n_g_v resultset is NOT empty");
777                 resultset->GetRowCount(numRows);
778             }
779             if (resultset == nullptr || numRows == 0) {
780                 SETTING_LOG_INFO("p_m n_g_v return def value");
781             } else {
782                 SETTING_LOG_INFO("p_m n_g_v return value from resultset");
783                 std::string val;
784                 int32_t columnIndex = 0;
785                 resultset->GoToFirstRow();
786                 resultset->GetString(columnIndex, val);
787                 asyncCallbackInfo->value = val;
788             }
789             if (resultset != nullptr) {
790                 resultset->Close();
791             }
792         },
793         // async end called callback
794         [](napi_env env, napi_status status, void* data) {
795             AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
796             SETTING_LOG_INFO("p_m end get c_b value is %{public}s",
797                 asyncCallbackInfo->value.c_str());
798             napi_value result = wrap_string_to_js(env, asyncCallbackInfo->value);
799             napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
800             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
801             asyncCallbackInfo->dataAbilityHelper = nullptr;
802             delete asyncCallbackInfo;
803         },
804         (void*)asyncCallbackInfo,
805         &asyncCallbackInfo->asyncWork);
806         napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
807         return promise;
808     }
809 }
810 
811 // api9
napi_get_value_ext(napi_env env,napi_callback_info info,const bool stageMode)812 napi_value napi_get_value_ext(napi_env env, napi_callback_info info, const bool stageMode)
813 {
814     AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo {
815         .env = env,
816         .asyncWork = nullptr,
817         .deferred = nullptr,
818         .callbackRef = nullptr,
819         .dataAbilityHelper = nullptr,
820         .key = "",
821         .value = "",
822         .uri = "",
823         .status = false,
824     };
825 
826     SETTING_LOG_INFO("n_g_v_e called");
827     size_t argc = ARGS_FOUR;
828     napi_value args[ARGS_FOUR] = {nullptr};
829     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
830 
831     std::shared_ptr<OHOS::DataShare::DataShareHelper> dataShareHelper = nullptr;
832     asyncCallbackInfo->dataShareHelper = getDataShareHelper(env, args[PARAM0], stageMode);
833 
834     asyncCallbackInfo->key = unwrap_string_from_js(env, args[PARAM1]);
835 
836     napi_value resource = nullptr;
837     NAPI_CALL(env, napi_create_string_utf8(env, "getValue", NAPI_AUTO_LENGTH, &resource));
838 
839     // set call type and table name, and check whether the parameter is valid
840     napi_valuetype valueType;
841     if (argc == ARGS_TWO) {
842         asyncCallbackInfo->callType = STAGE_PROMISE;
843         asyncCallbackInfo->tableName = "global";
844     } else if (argc == ARGS_THREE) {
845         NAPI_CALL(env, napi_typeof(env, args[PARAM2], &valueType));
846         if (valueType == napi_string) {
847             asyncCallbackInfo->tableName = unwrap_string_from_js(env, args[PARAM2]);
848             if (IsTableNameInvalid(asyncCallbackInfo->tableName)) {
849                 SETTING_LOG_ERROR("INVALID tableName [ARGS_THREE]");
850                 return wrap_void_to_js(env);
851             } else {
852                 asyncCallbackInfo->callType = STAGE_PROMISE_SPECIFIC;
853             }
854         } else {
855             asyncCallbackInfo->callType = STAGE_CALLBACK;
856             asyncCallbackInfo->tableName = "global";
857         }
858     } else if (argc == ARGS_FOUR) {
859         asyncCallbackInfo->callType = STAGE_CALLBACK_SPECIFIC;
860         asyncCallbackInfo->tableName = unwrap_string_from_js(env, args[PARAM3]);
861     } else {
862         asyncCallbackInfo->callType = INVALID_CALL;
863     }
864 
865     // check whether invalid call
866     if (asyncCallbackInfo->callType == INVALID_CALL) {
867         SETTING_LOG_ERROR("INVALID CALL");
868         return wrap_void_to_js(env);
869     }
870 
871     if (asyncCallbackInfo->callType == STAGE_CALLBACK || asyncCallbackInfo->callType == STAGE_CALLBACK_SPECIFIC) {
872         napi_create_reference(env, args[PARAM2], 1, &asyncCallbackInfo->callbackRef);
873         napi_create_async_work(
874             env,
875             nullptr,
876             resource,
877             GetValueExecuteExt,
878             [](napi_env env, napi_status status, void* data) {
879                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
880                 napi_value result = wrap_string_to_js(env, asyncCallbackInfo->value);
881                 CompleteCall(env, status, data, result);
882             },
883             (void*)asyncCallbackInfo,
884             &asyncCallbackInfo->asyncWork
885         );
886         NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
887         SETTING_LOG_INFO("c_b end async work");
888         return wrap_void_to_js(env);
889     } else if (asyncCallbackInfo->callType != INVALID_CALL) {
890         napi_value promise;
891         napi_deferred deferred;
892         NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
893         asyncCallbackInfo->deferred = deferred;
894         napi_create_async_work(
895             env,
896             nullptr,
897             resource,
898             GetValueExecuteExt,
899             [](napi_env env, napi_status status, void* data) {
900                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
901                 napi_value result = nullptr;
902                 result = wrap_string_to_js(env, asyncCallbackInfo->value);
903                 CompletePromise(env, status, data, result);
904             },
905             (void*)asyncCallbackInfo,
906             &asyncCallbackInfo->asyncWork
907         );
908         NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
909         return promise;
910     } else {
911         SETTING_LOG_ERROR("INVALID CALL");
912         return wrap_void_to_js(env);
913     }
914 }
915 
916 /**
917  * @brief setValue NAPI implementation.
918  *
919  * @param env the environment that the Node-API call is invoked under
920  * @param info the callback info passed into the callback function
921  * @return napi_value the return value from NAPI C++ to JS for the module.
922  */
napi_set_value_sync(napi_env env,napi_callback_info info)923 napi_value napi_set_value_sync(napi_env env, napi_callback_info info)
924 {
925     SETTING_LOG_INFO("n_s_v");
926 
927     // Check the number of the arguments
928     size_t argc = ARGS_FOUR;
929     napi_value args[ARGS_FOUR] = {nullptr};
930     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
931     if (argc != ARGS_THREE && argc != ARGS_FOUR) {
932         SETTING_LOG_ERROR("%{public}s, wrong number of arguments.", __func__);
933         return wrap_void_to_js(env);
934     }
935 
936     // Check the value type of the arguments
937     napi_valuetype valueType;
938     NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valueType));
939     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument[0] type. Object expected.");
940     NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valueType));
941     NAPI_ASSERT(env, valueType == napi_string, "Wrong argument[1] type. String expected.");
942     NAPI_CALL(env, napi_typeof(env, args[PARAM2], &valueType));
943     NAPI_ASSERT(env, valueType == napi_string, "Wrong argument[2] type. String expected.");
944 
945     bool stageMode = false;
946     napi_status status = OHOS::AbilityRuntime::IsStageContext(env, args[PARAM0], stageMode);
947     if (status == napi_ok) {
948         return napi_set_value_sync_ext(stageMode, argc, env, args);
949     }
950 
951     std::shared_ptr<DataAbilityHelper> dataAbilityHelper = nullptr;
952     NAPIDataAbilityHelperWrapper* wrapper = nullptr;
953     NAPI_CALL(env, napi_unwrap(env, args[PARAM0], reinterpret_cast<void **>(&wrapper)));
954     if (wrapper != nullptr) {
955         dataAbilityHelper = wrapper->GetDataAbilityHelper();
956     }
957 
958     std::string argsName = unwrap_string_from_js(env, args[PARAM1]);
959     std::string argsDefaultValue = unwrap_string_from_js(env, args[PARAM2]);
960 
961     OHOS::NativeRdb::ValuesBucket val;
962     val.PutString(SETTINGS_DATA_FIELD_KEYWORD, argsName);
963     val.PutString(SETTINGS_DATA_FIELD_VALUE, argsDefaultValue);
964 
965     std::vector<std::string> columns;
966     columns.push_back(SETTINGS_DATA_FIELD_VALUE);
967     OHOS::NativeRdb::DataAbilityPredicates predicates;
968     predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, argsName);
969 
970     std::shared_ptr<Uri> uri = std::make_shared<Uri>(SETTINGS_DATA_BASE_URI);
971     std::shared_ptr<OHOS::NativeRdb::AbsSharedResultSet> resultset = nullptr;
972     if (dataAbilityHelper != nullptr) {
973         resultset = dataAbilityHelper->Query(*uri, columns, predicates);
974     }
975     SETTING_LOG_INFO("n_s_v aft d_A_H->Query");
976 
977     int retInt = 0;
978     int numRows = 0;
979 
980     if (resultset != nullptr) {
981         SETTING_LOG_INFO("n_s_v resultset is NOT empty");
982         resultset->GetRowCount(numRows);
983     }
984 
985     // insert
986     if (resultset == nullptr || numRows == 0) {
987         retInt = dataAbilityHelper->Insert(*uri, val);
988         SETTING_LOG_INFO("n_s_v aft In");
989     // update
990     } else {
991         retInt = dataAbilityHelper->Update(*uri, val, predicates);
992         SETTING_LOG_INFO("n_s_v aft Up");
993     }
994     // notify change
995     if (retInt != 0) {
996         std::string uriWithNameStr =
997             argsName.empty() ? SETTINGS_DATA_BASE_URI : (SETTINGS_DATA_BASE_URI + "/" + argsName);
998         std::shared_ptr<Uri> uriWithName = std::make_shared<Uri>(uriWithNameStr);
999         dataAbilityHelper->NotifyChange(*uriWithName);
1000         SETTING_LOG_INFO("n_s_v aft NotifyChange with uri: %{public}s", uriWithNameStr.c_str());
1001     }
1002 
1003     if (resultset != nullptr) {
1004         resultset->Close();
1005     }
1006 
1007     return wrap_bool_to_js(env, retInt != 0);
1008 }
1009 
SetValueExecuteCB(napi_env env,void * data)1010 void SetValueExecuteCB(napi_env env, void *data)
1011 {
1012     if (data == nullptr) {
1013         SETTING_LOG_INFO("execute data is null");
1014         return;
1015     }
1016     AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1017 
1018     std::string argsName = asyncCallbackInfo->key;
1019     std::string argsDefaultValue = asyncCallbackInfo->value;
1020 
1021     OHOS::NativeRdb::ValuesBucket val;
1022     val.PutString(SETTINGS_DATA_FIELD_KEYWORD, argsName);
1023     val.PutString(SETTINGS_DATA_FIELD_VALUE, argsDefaultValue);
1024 
1025     std::vector<std::string> columns;
1026     columns.push_back(SETTINGS_DATA_FIELD_VALUE);
1027     OHOS::NativeRdb::DataAbilityPredicates predicates;
1028     predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, argsName);
1029 
1030     std::shared_ptr<Uri> uri = std::make_shared<Uri>(SETTINGS_DATA_BASE_URI);
1031     SETTING_LOG_INFO("execute bef d_A_H->Query");
1032     std::shared_ptr<OHOS::NativeRdb::AbsSharedResultSet> resultset = nullptr;
1033     if (asyncCallbackInfo->dataAbilityHelper != nullptr) {
1034         resultset = asyncCallbackInfo->dataAbilityHelper->Query(*uri, columns, predicates);
1035     }
1036 
1037     int retInt = 0;
1038     int numRows = 0;
1039     if (resultset != nullptr) {
1040         SETTING_LOG_INFO("execute resultset is NOT empty");
1041         resultset->GetRowCount(numRows);
1042     }
1043     // insert
1044     if (resultset == nullptr || numRows == 0) {
1045         retInt = asyncCallbackInfo->dataAbilityHelper->Insert(*uri, val);
1046         SETTING_LOG_INFO("execute aft In");
1047     // update
1048     } else {
1049         retInt = asyncCallbackInfo->dataAbilityHelper->Update(*uri, val, predicates);
1050         SETTING_LOG_INFO("execute aft Up");
1051     }
1052     // notify change
1053     if (retInt != 0) {
1054         std::string uriWithNameStr =
1055             argsName.empty() ? SETTINGS_DATA_BASE_URI : (SETTINGS_DATA_BASE_URI + "/" + argsName);
1056         std::shared_ptr<Uri> uriWithName = std::make_shared<Uri>(uriWithNameStr);
1057         asyncCallbackInfo->dataAbilityHelper->NotifyChange(*uriWithName);
1058         SETTING_LOG_INFO("execute aft NotifyC with uri: %{public}s", uriWithNameStr.c_str());
1059     }
1060     if (resultset != nullptr) {
1061         resultset->Close();
1062     }
1063     SETTING_LOG_INFO("execute... END!");
1064     asyncCallbackInfo->status = retInt;
1065 }
1066 
SetValueAsync(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)1067 napi_value SetValueAsync(napi_env env, AsyncCallbackInfo* asyncCallbackInfo)
1068 {
1069     SETTING_LOG_INFO("set do c_b");
1070     napi_value resource = nullptr;
1071     NAPI_CALL(env, napi_create_string_utf8(env, __func__, NAPI_AUTO_LENGTH, &resource));
1072 
1073     napi_create_async_work(
1074         env,
1075         nullptr,
1076         resource,
1077         SetValueExecuteCB,
1078         [](napi_env env, napi_status status, void* data) {
1079             if (data == nullptr) {
1080                 SETTING_LOG_INFO("c_b set asy end data is null");
1081                 return;
1082             }
1083             AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1084             napi_value undefine;
1085             napi_get_undefined(env, &undefine);
1086             napi_value callback = nullptr;
1087             napi_value result = wrap_bool_to_js(env, asyncCallbackInfo->status != 0);
1088             napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
1089             napi_call_function(env, nullptr, callback, 1, &result, &undefine);
1090             napi_delete_reference(env, asyncCallbackInfo->callbackRef);
1091             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1092             asyncCallbackInfo->dataAbilityHelper = nullptr;
1093             delete asyncCallbackInfo;
1094             SETTING_LOG_INFO("c_b set change complete");
1095         },
1096         (void*)asyncCallbackInfo,
1097         &asyncCallbackInfo->asyncWork
1098     );
1099     NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1100     SETTING_LOG_INFO("c_b set end asy work");
1101     return wrap_void_to_js(env);
1102 }
1103 
SetValuePromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)1104 napi_value SetValuePromise(napi_env env, AsyncCallbackInfo* asyncCallbackInfo)
1105 {
1106     SETTING_LOG_INFO("set do promise");
1107     napi_value promise;
1108     napi_deferred deferred;
1109     NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1110     asyncCallbackInfo->deferred = deferred;
1111 
1112     napi_value resource = nullptr;
1113     NAPI_CALL(env, napi_create_string_utf8(env, __func__, NAPI_AUTO_LENGTH, &resource));
1114 
1115     napi_create_async_work(
1116         env,
1117         nullptr,
1118         resource,
1119         SetValueExecuteCB,
1120         [](napi_env env, napi_status status, void* data) {
1121             AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1122             SETTING_LOG_INFO("p_m set end get c_b value is %{public}d",
1123                 asyncCallbackInfo->status);
1124             napi_value result = wrap_bool_to_js(env, asyncCallbackInfo->status != 0);
1125             napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1126             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1127             asyncCallbackInfo->dataAbilityHelper = nullptr;
1128             delete asyncCallbackInfo;
1129         },
1130         (void*)asyncCallbackInfo,
1131         &asyncCallbackInfo->asyncWork);
1132     napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1133     return promise;
1134 }
1135 
1136 /**
1137  * @brief setValue NAPI implementation.
1138  *
1139  * @param env the environment that the Node-API call is invoked under
1140  * @param info the callback info passed into the callback function
1141  * @return napi_value the return value from NAPI C++ to JS for the module.
1142  */
napi_set_value(napi_env env,napi_callback_info info)1143 napi_value napi_set_value(napi_env env, napi_callback_info info)
1144 {
1145     SETTING_LOG_INFO("set  napi_set_value");
1146 
1147     // getValue api need 3 parameters when Promise mode and need 4 parameters when callback mode
1148     const size_t paramOfCallback = ARGS_FOUR;
1149 
1150     size_t argc = ARGS_FIVE;
1151     napi_value args[ARGS_FIVE] = {nullptr};
1152     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1153     if (argc != ARGS_THREE && argc != ARGS_FOUR && argc != ARGS_FIVE) {
1154         SETTING_LOG_ERROR(
1155             "set %{public}s, wrong number of arguments, expect 3 or 4 or 5 but get %{public}zd",
1156             __func__,
1157             argc);
1158         return wrap_void_to_js(env);
1159     }
1160 
1161     SETTING_LOG_INFO("set  arg count is %{public}zd", argc);
1162     // Check the value type of the arguments
1163     AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo {
1164         .env = env,
1165         .asyncWork = nullptr,
1166         .deferred = nullptr,
1167         .callbackRef = nullptr,
1168         .dataAbilityHelper = nullptr,
1169         .key = "",
1170         .value = "",
1171         .uri = "",
1172         .status = false,
1173     };
1174     SETTING_LOG_INFO("set  aft create aysnc call back info");
1175     napi_valuetype valueType;
1176     NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valueType));
1177     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument[0] type. Object expected.");
1178     NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valueType));
1179     NAPI_ASSERT(env, valueType == napi_string, "Wrong argument[1], type. String expected");
1180     NAPI_CALL(env, napi_typeof(env, args[PARAM2], &valueType));
1181     NAPI_ASSERT(env, valueType == napi_string, "Wrong argument[2], type. String expected");
1182 
1183     // api9 napi_set_value_ext
1184     bool stageMode = false;
1185     napi_status status = OHOS::AbilityRuntime::IsStageContext(env, args[PARAM0], stageMode);
1186     if (status == napi_ok) {
1187         SETTING_LOG_INFO("argv[0] is a context, Stage Model: %{public}d", stageMode);
1188         return napi_set_value_ext(env, info, stageMode);
1189     }
1190 
1191     NAPIDataAbilityHelperWrapper* wrapper = nullptr;
1192     NAPI_CALL(env, napi_unwrap(env, args[PARAM0], reinterpret_cast<void **>(&wrapper)));
1193     if (wrapper != nullptr) {
1194         asyncCallbackInfo->dataAbilityHelper = wrapper->GetDataAbilityHelper();
1195     }
1196 
1197     asyncCallbackInfo->key = unwrap_string_from_js(env, args[PARAM1]);
1198     asyncCallbackInfo->value = unwrap_string_from_js(env, args[PARAM2]);
1199     SETTING_LOG_INFO("set  input param is : (key %{public}s, value %{public}s)",
1200         asyncCallbackInfo->key.c_str(), asyncCallbackInfo->value.c_str());
1201 
1202     napi_value ret = nullptr;
1203     if (argc == paramOfCallback) {
1204         napi_create_reference(env, args[PARAM3], 1, &asyncCallbackInfo->callbackRef);
1205         ret = SetValueAsync(env, asyncCallbackInfo);
1206     } else {
1207         ret = SetValuePromise(env, asyncCallbackInfo);
1208     }
1209     SETTING_LOG_INFO("set  value end");
1210     return ret;
1211 }
1212 
napi_set_value_ext(napi_env env,napi_callback_info info,const bool stageMode)1213 napi_value napi_set_value_ext(napi_env env, napi_callback_info info, const bool stageMode)
1214 {
1215     AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo {
1216         .env = env,
1217         .asyncWork = nullptr,
1218         .deferred = nullptr,
1219         .callbackRef = nullptr,
1220         .dataAbilityHelper = nullptr,
1221         .key = "",
1222         .value = "",
1223         .uri = "",
1224         .status = false,
1225     };
1226 
1227     size_t argc = ARGS_FIVE;
1228     napi_value args[ARGS_FIVE] = {nullptr};
1229     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1230 
1231     asyncCallbackInfo->dataShareHelper = getDataShareHelper(env, args[PARAM0], stageMode);
1232     asyncCallbackInfo->key = unwrap_string_from_js(env, args[PARAM1]);
1233     asyncCallbackInfo->uri = unwrap_string_from_js(env, args[PARAM2]); //temp
1234     napi_value resource = nullptr;
1235     NAPI_CALL(env, napi_create_string_utf8(env, "napi_set_value_ext", NAPI_AUTO_LENGTH, &resource));
1236 
1237     // set call type and table name
1238     napi_valuetype valueType;
1239     if (argc == ARGS_THREE) {
1240         asyncCallbackInfo->callType = STAGE_PROMISE;
1241         asyncCallbackInfo->tableName = "global";
1242     } else if (argc == ARGS_FOUR) {
1243         NAPI_CALL(env, napi_typeof(env, args[PARAM3], &valueType));
1244         if (valueType == napi_string) {
1245             asyncCallbackInfo->tableName = unwrap_string_from_js(env, args[PARAM3]);
1246             if (IsTableNameInvalid(asyncCallbackInfo->tableName)) {
1247                 SETTING_LOG_ERROR("INVALID tableName [ARGS_FOUR]");
1248                 return wrap_void_to_js(env);
1249             } else {
1250                 asyncCallbackInfo->callType = STAGE_PROMISE_SPECIFIC;
1251             }
1252         } else {
1253             asyncCallbackInfo->callType = STAGE_CALLBACK;
1254             asyncCallbackInfo->tableName = "global";
1255         }
1256     } else if (argc == ARGS_FIVE) {
1257         asyncCallbackInfo->callType = STAGE_CALLBACK_SPECIFIC;
1258         asyncCallbackInfo->tableName = unwrap_string_from_js(env, args[PARAM4]);
1259     } else {
1260         asyncCallbackInfo->callType = INVALID_CALL;
1261     }
1262 
1263     // check whether invalid call
1264     if (asyncCallbackInfo->callType == INVALID_CALL) {
1265         SETTING_LOG_ERROR("INVALID CALL");
1266         return wrap_void_to_js(env);
1267     }
1268 
1269     if (asyncCallbackInfo->callType == STAGE_CALLBACK || asyncCallbackInfo->callType == STAGE_CALLBACK_SPECIFIC) {
1270         napi_create_reference(env, args[PARAM3], 1, &asyncCallbackInfo->callbackRef);
1271         napi_create_async_work(
1272             env,
1273             nullptr,
1274             resource,
1275             [](napi_env env, void* data) {
1276                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1277                 GetValueExecuteExt(env, (void*)asyncCallbackInfo);
1278                 SetValueExecuteExt(env, (void*)asyncCallbackInfo, asyncCallbackInfo->uri);
1279             },
1280             [](napi_env env, napi_status status, void* data) {
1281                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1282                 napi_value result = wrap_bool_to_js(env, asyncCallbackInfo->status != 0);
1283                 asyncCallbackInfo->status = napi_ok;
1284                 CompleteCall(env, status, data, result);
1285             },
1286             (void*)asyncCallbackInfo,
1287             &asyncCallbackInfo->asyncWork
1288         );
1289         NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1290         SETTING_LOG_INFO("c_b end async work");
1291         return wrap_void_to_js(env);
1292     } else if (asyncCallbackInfo->callType != INVALID_CALL) {
1293         napi_value promise;
1294         napi_deferred deferred;
1295         NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1296         asyncCallbackInfo->deferred = deferred;
1297         napi_create_async_work(
1298             env,
1299             nullptr,
1300             resource,
1301             [](napi_env env, void* data) {
1302                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1303                 SETTING_LOG_INFO("in async work");
1304                 GetValueExecuteExt(env, (void*)asyncCallbackInfo);
1305                 SetValueExecuteExt(env, (void*)asyncCallbackInfo, asyncCallbackInfo->uri);
1306             },
1307             [](napi_env env, napi_status status, void* data) {
1308                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1309                 napi_value result = wrap_bool_to_js(env, asyncCallbackInfo->status != 0);
1310                 asyncCallbackInfo->status = napi_ok;
1311                 CompletePromise(env, status, data, result);
1312             },
1313             (void*)asyncCallbackInfo,
1314             &asyncCallbackInfo->asyncWork
1315         );
1316         NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1317         return promise;
1318     } else {
1319         SETTING_LOG_ERROR("INVALID CALL");
1320         return wrap_void_to_js(env);
1321     }
1322 }
1323 /**
1324  * @brief enableAirplaneMode NAPI implementation.
1325  * @param env the environment that the Node-API call is invoked under
1326  * @param info the callback info passed into the callback function
1327  * @return napi_value the return value from NAPI C++ to JS for the module.
1328  */
napi_enable_airplane_mode(napi_env env,napi_callback_info info)1329 napi_value napi_enable_airplane_mode(napi_env env, napi_callback_info info)
1330 {
1331     const size_t paramOfPromise = ARGS_ONE;
1332     const size_t paramOfCallback = ARGS_TWO;
1333 
1334     size_t argc = ARGS_TWO;
1335     napi_value args[ARGS_TWO] = {nullptr};
1336     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1337     if (argc != paramOfCallback && argc != paramOfPromise) {
1338         SETTING_LOG_ERROR("%{public}s, wrong number of arguments, expect 1 or 2 but get %{public}zd",
1339             __func__, argc);
1340         return wrap_void_to_js(env);
1341     }
1342 
1343     SETTING_LOG_INFO("n_e_a_m arg count is %{public}zd", argc);
1344     AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo {
1345         .env = env,
1346         .asyncWork = nullptr,
1347         .deferred = nullptr,
1348         .callbackRef = nullptr,
1349         .dataAbilityHelper = nullptr,
1350         .key = "",
1351         .value = "",
1352         .uri = "",
1353         .status = 0,
1354     };
1355     SETTING_LOG_INFO("aft create aysnc call back info");
1356 
1357     napi_valuetype valueType;
1358     NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valueType));
1359     NAPI_ASSERT(env, valueType == napi_boolean, "Wrong argument[0], type. Boolean expected");
1360 
1361     napi_value resource = nullptr;
1362     NAPI_CALL(env, napi_create_string_utf8(env, "enableAirplaneMode", NAPI_AUTO_LENGTH, &resource));
1363 
1364     if (argc == paramOfCallback) {
1365         SETTING_LOG_INFO("%{public}s, asyncCallback.", __func__);
1366 
1367         napi_create_reference(env, args[PARAM1], 1, &asyncCallbackInfo->callbackRef);
1368         napi_create_async_work(
1369             env,
1370             nullptr,
1371             resource,
1372             [](napi_env env, void* data) {},
1373             [](napi_env env, napi_status status, void* data) {
1374                 if (data == nullptr) {
1375                     SETTING_LOG_INFO("c_b asy end data is null");
1376                     return;
1377                 }
1378                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1379 
1380                 napi_value callback = nullptr;
1381                 napi_value undefined;
1382                 napi_get_undefined(env, &undefined);
1383 
1384                 napi_value result[PARAM2] = {0};
1385 
1386                 // create error code
1387                 napi_value error = nullptr;
1388                 napi_create_object(env, &error);
1389                 int unSupportCode = 801;
1390                 napi_value errCode = nullptr;
1391                 napi_create_int32(env, unSupportCode, &errCode);
1392                 napi_set_named_property(env, error, "code", errCode);
1393                 result[0] = error;
1394                 napi_get_undefined(env, &result[1]);
1395 
1396                 napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
1397                 napi_value callResult;
1398                 napi_call_function(env, undefined, callback, PARAM2, result, &callResult);
1399 
1400                 napi_delete_reference(env, asyncCallbackInfo->callbackRef);
1401                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1402                 delete asyncCallbackInfo;
1403                 SETTING_LOG_INFO("c_b change c_b complete");
1404             },
1405             (void*)asyncCallbackInfo,
1406             &asyncCallbackInfo->asyncWork
1407         );
1408         NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1409         return wrap_void_to_js(env);
1410     } else {
1411         SETTING_LOG_INFO("%{public}s, promise.", __func__);
1412         napi_deferred deferred;
1413         napi_value promise;
1414         NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1415         asyncCallbackInfo->deferred = deferred;
1416 
1417         napi_create_async_work(
1418             env,
1419             nullptr,
1420             resource,
1421             [](napi_env env, void *data) {},
1422             [](napi_env env, napi_status status, void *data) {
1423                 SETTING_LOG_INFO("%{public}s, promise complete", __func__);
1424                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1425 
1426                 napi_value result;
1427                 napi_value error = nullptr;
1428                 napi_create_object(env, &error);
1429                 int unSupportCode = 801;
1430                 napi_value errCode = nullptr;
1431                 napi_create_int32(env, unSupportCode, &errCode);
1432                 napi_set_named_property(env, error, "code", errCode);
1433                 result = error;
1434 
1435                 napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
1436                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1437                 delete asyncCallbackInfo;
1438             },
1439             (void *)asyncCallbackInfo,
1440             &asyncCallbackInfo->asyncWork);
1441         napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1442         return promise;
1443     }
1444 }
1445 
1446 /**
1447  * @brief canShowFloating NAPI implementation.
1448  * @param env the environment that the Node-API call is invoked under
1449  * @param info the callback info passed into the callback function
1450  * @return napi_value the return value from NAPI C++ to JS for the module.
1451  */
napi_can_show_floating(napi_env env,napi_callback_info info)1452 napi_value napi_can_show_floating(napi_env env, napi_callback_info info)
1453 {
1454     const size_t paramOfPromise = PARAM0;
1455     const size_t paramOfCallback = PARAM1;
1456 
1457     size_t argc = PARAM1;
1458     napi_value args[PARAM1] = {nullptr};
1459     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1460     if (argc != paramOfCallback && argc != paramOfPromise) {
1461         SETTING_LOG_ERROR("%{public}s, wrong number of arguments, expect 0 or 1 but get %{public}zd",
1462             __func__, argc);
1463         return wrap_void_to_js(env);
1464     }
1465 
1466     SETTING_LOG_INFO("n_e_a_m arg count is %{public}zd", argc);
1467     AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo {
1468         .env = env,
1469         .asyncWork = nullptr,
1470         .deferred = nullptr,
1471         .callbackRef = nullptr,
1472         .dataAbilityHelper = nullptr,
1473         .key = "",
1474         .value = "",
1475         .uri = "",
1476         .status = 0,
1477     };
1478 
1479     napi_value resource = nullptr;
1480     NAPI_CALL(env, napi_create_string_utf8(env, "enableAirplaneMode", NAPI_AUTO_LENGTH, &resource));
1481 
1482     if (argc == paramOfCallback) {
1483         SETTING_LOG_INFO("%{public}s, a_C_B.", __func__);
1484 
1485         napi_create_reference(env, args[PARAM0], 1, &asyncCallbackInfo->callbackRef);
1486         napi_create_async_work(
1487             env,
1488             nullptr,
1489             resource,
1490             [](napi_env env, void* data) {},
1491             [](napi_env env, napi_status status, void* data) {
1492                 if (data == nullptr) {
1493                     SETTING_LOG_INFO("c_b asy end data is null");
1494                     return;
1495                 }
1496                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1497 
1498                 napi_value callback = nullptr;
1499                 napi_value undefined;
1500                 napi_get_undefined(env, &undefined);
1501 
1502                 napi_value result[PARAM2] = {0};
1503 
1504                 // create error code
1505                 napi_value error = nullptr;
1506                 napi_create_object(env, &error);
1507                 int unSupportCode = 801;
1508                 napi_value errCode = nullptr;
1509                 napi_create_int32(env, unSupportCode, &errCode);
1510                 napi_set_named_property(env, error, "code", errCode);
1511                 result[0] = error;
1512                 result[1] = wrap_bool_to_js(env, false);
1513 
1514                 napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
1515                 napi_value callResult;
1516                 napi_call_function(env, undefined, callback, PARAM2, result, &callResult);
1517 
1518                 napi_delete_reference(env, asyncCallbackInfo->callbackRef);
1519                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1520                 delete asyncCallbackInfo;
1521                 SETTING_LOG_INFO("c_b change complete");
1522             },
1523             (void*)asyncCallbackInfo,
1524             &asyncCallbackInfo->asyncWork
1525         );
1526         NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1527         return wrap_void_to_js(env);
1528     } else {
1529         SETTING_LOG_INFO("%{public}s, promise.", __func__);
1530         napi_deferred deferred;
1531         napi_value promise;
1532         NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1533         asyncCallbackInfo->deferred = deferred;
1534 
1535         napi_create_async_work(
1536             env,
1537             nullptr,
1538             resource,
1539             [](napi_env env, void *data) {},
1540             [](napi_env env, napi_status status, void *data) {
1541                 SETTING_LOG_INFO("%{public}s, promise complete", __func__);
1542                 AsyncCallbackInfo* asyncCallbackInfo = (AsyncCallbackInfo*)data;
1543 
1544                 napi_value result;
1545                 napi_value error = nullptr;
1546                 napi_create_object(env, &error);
1547                 int unSupportCode = 801;
1548                 napi_value errCode = nullptr;
1549                 napi_create_int32(env, unSupportCode, &errCode);
1550                 napi_set_named_property(env, error, "code", errCode);
1551                 result = error;
1552 
1553                 napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
1554                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1555                 delete asyncCallbackInfo;
1556             },
1557             (void *)asyncCallbackInfo,
1558             &asyncCallbackInfo->asyncWork);
1559         napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1560         return promise;
1561     }
1562 }
1563 
1564 // get uri for stage model
GetStageUriStr(std::string tableName,std::string idStr,std::string keyStr)1565 std::string GetStageUriStr(std::string tableName, std::string idStr, std::string keyStr)
1566 {
1567     if (std::stoi(idStr) < USERID_HELPER_NUMBER) {
1568         idStr = "100";
1569     }
1570     if (tableName == "global") {
1571         std::string retStr =
1572             "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=" + keyStr;
1573         return retStr;
1574     } else if (tableName == "system") {
1575         std::string retStr = "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_" + idStr +
1576                              "?Proxy=true&key=" + keyStr;
1577         return retStr;
1578     } else if (tableName == "secure") {
1579         std::string retStr = "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_" + idStr +
1580                              "?Proxy=true&key=" + keyStr;
1581         return retStr;
1582     } else {
1583         // return global uri
1584         std::string retStr =
1585             "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=" + keyStr;
1586         return retStr;
1587     }
1588 }
1589 
1590 // get proxy uri
GetProxyUriStr(std::string tableName,std::string idStr)1591 std::string GetProxyUriStr(std::string tableName, std::string idStr)
1592 {
1593     if (std::stoi(idStr) < USERID_HELPER_NUMBER) {
1594         idStr = "100";
1595     }
1596     if (tableName == "global") {
1597         // return global uri
1598         std::string retStr = "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
1599         return retStr;
1600     } else if (tableName == "system") {
1601         std::string retStr =
1602             "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_" + idStr + "?Proxy=true";
1603         return retStr;
1604     } else {
1605         std::string retStr =
1606             "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_" + idStr + "?Proxy=true";
1607         return retStr;
1608     }
1609 }
1610 
1611 // check whether tableName is invalid, invalid -> true valid -> false
IsTableNameInvalid(std::string tableName)1612 bool IsTableNameInvalid(std::string tableName)
1613 {
1614     if (tableName != "global" && tableName != "system" && tableName != "secure") {
1615         return true;
1616     } else {
1617         return false;
1618     }
1619 }
1620 
napi_get_value_sync_ext(bool stageMode,size_t argc,napi_env env,napi_value * args)1621 napi_value napi_get_value_sync_ext(bool stageMode, size_t argc, napi_env env, napi_value* args)
1622 {
1623     SETTING_LOG_INFO("argv[0] is a context, Stage Model: %{public}d", stageMode);
1624     AsyncCallbackInfo *asyncCallbackInfo = new AsyncCallbackInfo();
1625     napi_valuetype valueType;
1626 
1627     // define table name
1628     if (argc == ARGS_FOUR) {
1629         // check whether tableName is ok
1630         NAPI_CALL(env, napi_typeof(env, args[PARAM3], &valueType));
1631         if (valueType != napi_string) {
1632             SETTING_LOG_ERROR("tableName IS NOT STRING");
1633             return wrap_void_to_js(env);
1634         } else {
1635             asyncCallbackInfo->tableName = unwrap_string_from_js(env, args[PARAM3]);
1636             if (IsTableNameInvalid(asyncCallbackInfo->tableName)) {
1637                 SETTING_LOG_ERROR("INVALID tableName");
1638                 return wrap_void_to_js(env);
1639             }
1640         }
1641     } else {
1642         asyncCallbackInfo->tableName = "global";
1643     }
1644 
1645     asyncCallbackInfo->key = unwrap_string_from_js(env, args[PARAM1]);
1646     std::shared_ptr<OHOS::DataShare::DataShareHelper> dataShareHelper = nullptr;
1647     asyncCallbackInfo->dataShareHelper = getDataShareHelper(env, args[PARAM0], stageMode, asyncCallbackInfo->tableName);
1648     GetValueExecuteExt(env, (void *)asyncCallbackInfo);
1649     SETTING_LOG_INFO(
1650         "n_g_v return  %{public}s", asyncCallbackInfo->value.c_str());
1651     napi_value retVal = nullptr;
1652     if (asyncCallbackInfo->value.size() <= 0) {
1653         retVal = args[PARAM2];
1654     } else {
1655         retVal = wrap_string_to_js(env, asyncCallbackInfo->value);
1656     }
1657     delete asyncCallbackInfo;
1658     return retVal;
1659 }
1660 
napi_set_value_sync_ext(bool stageMode,size_t argc,napi_env env,napi_value * args)1661 napi_value napi_set_value_sync_ext(bool stageMode, size_t argc, napi_env env, napi_value *args)
1662 {
1663     SETTING_LOG_INFO("argv[0] is a context, Stage Model: %{public}d", stageMode);
1664     AsyncCallbackInfo *asyncCallbackInfo = new AsyncCallbackInfo();
1665     asyncCallbackInfo->key = unwrap_string_from_js(env, args[PARAM1]);
1666     napi_valuetype valueType;
1667 
1668     // define table name
1669     if (argc == ARGS_FOUR) {
1670         NAPI_CALL(env, napi_typeof(env, args[PARAM3], &valueType));
1671         if (valueType != napi_string) {
1672             SETTING_LOG_ERROR("tableName IS NOT STRING");
1673             return wrap_void_to_js(env);
1674         } else {
1675             asyncCallbackInfo->tableName = unwrap_string_from_js(env, args[PARAM3]);
1676             if (IsTableNameInvalid(asyncCallbackInfo->tableName)) {
1677                 SETTING_LOG_ERROR("INVALID tableName");
1678                 return wrap_void_to_js(env);
1679             }
1680         }
1681     } else {
1682         asyncCallbackInfo->tableName = "global";
1683     }
1684     std::shared_ptr<OHOS::DataShare::DataShareHelper> dataShareHelper = nullptr;
1685     asyncCallbackInfo->dataShareHelper = getDataShareHelper(env, args[PARAM0], stageMode, asyncCallbackInfo->tableName);
1686     GetValueExecuteExt(env, (void *)asyncCallbackInfo);
1687     SetValueExecuteExt(env, (void *)asyncCallbackInfo, unwrap_string_from_js(env, args[PARAM2]));
1688     napi_value result = wrap_bool_to_js(env, asyncCallbackInfo->status != 0);
1689     delete asyncCallbackInfo;
1690     return result;
1691 }
1692 
napi_register_key_observer(napi_env env,napi_callback_info info)1693 napi_value napi_register_key_observer(napi_env env, napi_callback_info info)
1694 {
1695     return npai_settings_register_observer(env, info);
1696 }
1697 
napi_unregister_key_observer(napi_env env,napi_callback_info info)1698 napi_value napi_unregister_key_observer(napi_env env, napi_callback_info info)
1699 {
1700     return npai_settings_unregister_observer(env, info);
1701 }
1702 }  // namespace Settings
1703 }  // namespace OHOS
1704