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 "js_distributedobjectstore.h"
17
18 #include <random>
19
20 #include "accesstoken_kit.h"
21 #include "js_ability.h"
22 #include "js_common.h"
23 #include "js_distributedobject.h"
24 #include "js_util.h"
25 #include "logger.h"
26 #include "object_error.h"
27 #include "objectstore_errors.h"
28
29 namespace OHOS::ObjectStore {
30 constexpr size_t TYPE_SIZE = 20;
31 constexpr size_t PARAM_COUNT_MAX = 3;
32 static ConcurrentMap<std::string, std::list<napi_ref>> g_statusCallBacks;
33 static ConcurrentMap<std::string, std::list<napi_ref>> g_changeCallBacks;
34 static ConcurrentMap<std::string, std::list<napi_ref>> g_progressCallBacks;
AddCallback(napi_env env,ConcurrentMap<std::string,std::list<napi_ref>> & callbacks,const std::string & objectId,napi_value callback)35 bool JSDistributedObjectStore::AddCallback(napi_env env, ConcurrentMap<std::string, std::list<napi_ref>> &callbacks,
36 const std::string &objectId, napi_value callback)
37 {
38 LOG_INFO("add callback %{public}s", objectId.c_str());
39 napi_ref ref = nullptr;
40 napi_status status = napi_create_reference(env, callback, 1, &ref);
41 if (status != napi_ok) {
42 return false;
43 }
44 return callbacks.Compute(objectId, [&ref](const std::string &key, std::list<napi_ref> &lists) {
45 lists.push_back(ref);
46 return true;
47 });
48 }
49
DeleteAllCallback(napi_env env,std::list<napi_ref> & lists)50 bool DeleteAllCallback(napi_env env, std::list<napi_ref> &lists)
51 {
52 for (auto iter = lists.begin(); iter != lists.end();) {
53 if (*iter == nullptr) {
54 iter++;
55 continue;
56 }
57 napi_status status = napi_delete_reference(env, *iter);
58 NOT_MATCH_RETURN_FALSE(status == napi_ok);
59 iter = lists.erase(iter);
60 }
61 return false;
62 }
63
DeleteSingleCallback(napi_env env,std::list<napi_ref> & lists,napi_value callback)64 bool DeleteSingleCallback(napi_env env, std::list<napi_ref> &lists, napi_value callback)
65 {
66 napi_value callbackTmp;
67 for (auto iter = lists.begin(); iter != lists.end();) {
68 if (*iter == nullptr) {
69 iter++;
70 continue;
71 }
72 napi_status status = napi_get_reference_value(env, *iter, &callbackTmp);
73 NOT_MATCH_RETURN_FALSE(status == napi_ok);
74 bool isEquals = false;
75 napi_strict_equals(env, callbackTmp, callback, &isEquals);
76 if (isEquals) {
77 napi_delete_reference(env, *iter);
78 iter = lists.erase(iter);
79 } else {
80 iter++;
81 }
82 }
83 return !lists.empty();
84 }
85
DelCallback(napi_env env,ConcurrentMap<std::string,std::list<napi_ref>> & callbacks,const std::string & sessionId,napi_value callback)86 bool JSDistributedObjectStore::DelCallback(napi_env env, ConcurrentMap<std::string, std::list<napi_ref>> &callbacks,
87 const std::string &sessionId, napi_value callback)
88 {
89 LOG_INFO("del callback %{public}s", sessionId.c_str());
90 auto execute = [&env, callback](const std::string &key, std::list<napi_ref> &lists) {
91 if (callback == nullptr) {
92 return DeleteAllCallback(env, lists);
93 } else {
94 return DeleteSingleCallback(env, lists, callback);
95 }
96 };
97 return callbacks.ComputeIfPresent(sessionId, execute);
98 }
99
NewDistributedObject(napi_env env,DistributedObjectStore * objectStore,DistributedObject * object,const std::string & objectId)100 napi_value JSDistributedObjectStore::NewDistributedObject(
101 napi_env env, DistributedObjectStore *objectStore, DistributedObject *object, const std::string &objectId)
102 {
103 napi_value result;
104 napi_status status = napi_new_instance(env, JSDistributedObject::GetCons(env), 0, nullptr, &result);
105 NOT_MATCH_RETURN_NULL(status == napi_ok);
106 JSObjectWrapper *objectWrapper = new (std::nothrow) JSObjectWrapper(objectStore, object);
107 if (objectWrapper == nullptr) {
108 LOG_ERROR("JSDistributedObjectStore::NewDistributedObject no memory for objectWrapper malloc!");
109 return nullptr;
110 }
111 objectWrapper->SetObjectId(objectId);
112 status = napi_wrap(
113 env, result, objectWrapper,
114 [](napi_env env, void *data, void *hint) {
115 if (data == nullptr) {
116 LOG_WARN("objectWrapper is nullptr.");
117 return;
118 }
119 auto objectWrapper = static_cast<JSObjectWrapper *>(data);
120
121 JSDistributedObjectStore::DelCallback(env, g_changeCallBacks, objectWrapper->GetObjectId());
122 JSDistributedObjectStore::DelCallback(env, g_statusCallBacks, objectWrapper->GetObjectId());
123
124 if (objectWrapper->GetObject() == nullptr) {
125 delete objectWrapper;
126 return;
127 }
128 LOG_INFO("start delete object");
129 DistributedObjectStore::GetInstance(JSDistributedObjectStore::GetBundleName(env))
130 ->DeleteObject(objectWrapper->GetObject()->GetSessionId());
131 delete objectWrapper;
132 },
133 nullptr, nullptr);
134 if (status != napi_ok) {
135 LOG_WARN("error! napi_wrap failed.");
136 delete objectWrapper;
137 return nullptr;
138 }
139
140 RestoreWatchers(env, objectWrapper, objectId);
141 objectStore->NotifyCachedStatus(object->GetSessionId());
142 objectStore->NotifyProgressStatus(object->GetSessionId());
143 NOT_MATCH_RETURN_NULL(status == napi_ok);
144 return result;
145 }
146
147 // function createObjectSync(version: number, sessionId: string, objectId:string): DistributedObject;
148 // function createObjectSync(version: number, sessionId: string, objectId:string, context: Context): DistributedObject;
JSCreateObjectSync(napi_env env,napi_callback_info info)149 napi_value JSDistributedObjectStore::JSCreateObjectSync(napi_env env, napi_callback_info info)
150 {
151 size_t requireArgc = 3;
152 size_t argc = 4;
153 napi_value argv[4] = { 0 };
154 napi_value thisVar = nullptr;
155 void *data = nullptr;
156 double version = 8;
157 std::string sessionId;
158 std::string objectId;
159 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
160 NOT_MATCH_RETURN_NULL(status == napi_ok);
161 auto innerError = std::make_shared<InnerError>();
162 NAPI_ASSERT_ERRCODE_V9(env, argc >= 1, version, innerError);
163
164 status = JSUtil::GetValue(env, argv[0], version);
165 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && argc >= requireArgc, version,
166 std::make_shared<ParametersNum>("1 or 2"));
167 NAPI_ASSERT_ERRCODE_V9(env, !IsSandBox(), version, innerError);
168 LOG_INFO("start JSCreateObjectSync");
169 status = JSUtil::GetValue(env, argv[1], sessionId);
170 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok, version,
171 std::make_shared<ParametersType>("sessionId", "string"));
172
173 status = JSUtil::GetValue(env, argv[2], objectId);
174 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok, version, innerError);
175 std::string bundleName = "";
176 if (argc > requireArgc) {
177 bool executeResult = JSDistributedObjectStore::GetBundleNameWithContext(env, argv[3], bundleName);
178 NAPI_ASSERT_ERRCODE_V9(env, executeResult, version, innerError);
179 } else {
180 bundleName = JSDistributedObjectStore::GetBundleName(env);
181 }
182 DistributedObjectStore *objectInfo = DistributedObjectStore::GetInstance(bundleName);
183 NAPI_ASSERT_ERRCODE_V9(env, objectInfo != nullptr, version, innerError);
184 uint32_t result = 0;
185 DistributedObject *object = objectInfo->CreateObject(sessionId, result);
186 NAPI_ASSERT_ERRCODE_V9(env, result != ERR_EXIST, version, std::make_shared<DatabaseError>());
187 NAPI_ASSERT_ERRCODE_V9(env, result != ERR_NO_PERMISSION, version, std::make_shared<PermissionError>());
188 NAPI_ASSERT_ERRCODE_V9(env, result == SUCCESS && object != nullptr, version, innerError);
189 return NewDistributedObject(env, objectInfo, object, objectId);
190 }
191
192 // function destroyObjectSync(version: number, object: DistributedObject): number;
JSDestroyObjectSync(napi_env env,napi_callback_info info)193 napi_value JSDistributedObjectStore::JSDestroyObjectSync(napi_env env, napi_callback_info info)
194 {
195 double version = 8;
196 LOG_INFO("start");
197 size_t requireArgc = 2;
198 size_t argc = 2;
199 napi_value argv[2] = { 0 };
200 napi_value thisVar = nullptr;
201 void *data = nullptr;
202 std::string sessionId;
203 std::string bundleName;
204 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
205 NOT_MATCH_RETURN_NULL(status == napi_ok);
206 status = JSUtil::GetValue(env, argv[0], version);
207 NOT_MATCH_RETURN_NULL(status == napi_ok && argc >= requireArgc);
208
209 JSObjectWrapper *objectWrapper = nullptr;
210 status = napi_unwrap(env, argv[1], (void **)&objectWrapper);
211 auto innerError = std::make_shared<InnerError>();
212 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && objectWrapper != nullptr, version, innerError);
213
214 DistributedObjectStore *objectInfo =
215 DistributedObjectStore::GetInstance(JSDistributedObjectStore::GetBundleName(env));
216 NAPI_ASSERT_ERRCODE_V9(env, objectInfo != nullptr && objectWrapper->GetObject() != nullptr, version, innerError);
217
218 objectWrapper->DeleteWatch(env, Constants::CHANGE);
219 objectWrapper->DeleteWatch(env, Constants::STATUS);
220 objectWrapper->DeleteWatch(env, Constants::PROGRESS);
221 objectInfo->DeleteObject(objectWrapper->GetObject()->GetSessionId());
222 objectWrapper->DestroyObject();
223 return nullptr;
224 }
225
226 // function on(version: number, type: 'change', object: DistributedObject,
227 // callback: Callback<ChangedDataObserver>): void;
228 // function on(version: number, type: 'status', object: DistributedObject,
229 // callback: Callback<ObjectStatusObserver>): void;
JSOn(napi_env env,napi_callback_info info)230 napi_value JSDistributedObjectStore::JSOn(napi_env env, napi_callback_info info)
231 {
232 double version = 8;
233 LOG_INFO("start");
234 size_t requireArgc = 4;
235 size_t argc = 4;
236 napi_value argv[4] = { 0 };
237 napi_value thisVar = nullptr;
238 void *data = nullptr;
239 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
240 auto innerError = std::make_shared<InnerError>();
241 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && argc >= 1, version, innerError);
242
243 status = JSUtil::GetValue(env, argv[0], version);
244 NOT_MATCH_RETURN_NULL(status == napi_ok);
245 NAPI_ASSERT_ERRCODE_V9(env, argc >= requireArgc, version, std::make_shared<ParametersNum>("2"));
246
247 char type[TYPE_SIZE] = { 0 };
248 size_t eventTypeLen = 0;
249 status = napi_get_value_string_utf8(env, argv[1], type, TYPE_SIZE, &eventTypeLen);
250 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok, version, std::make_shared<ParametersType>("type", "string"));
251
252 napi_valuetype valueType = napi_undefined;
253 status = napi_typeof(env, argv[2], &valueType);
254 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && valueType == napi_object, version, innerError);
255
256 JSObjectWrapper *wrapper = nullptr;
257 status = napi_unwrap(env, argv[2], (void **)&wrapper);
258 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && wrapper != nullptr, version, innerError);
259
260 status = napi_typeof(env, argv[3], &valueType);
261 NAPI_ASSERT_ERRCODE_V9(env, valueType == napi_function, version,
262 std::make_shared<ParametersType>("callback", "function"));
263 bool addResult = wrapper->AddWatch(env, type, argv[3]);
264 NAPI_ASSERT_ERRCODE_V9(env, addResult, version, innerError);
265 napi_value result = nullptr;
266 napi_get_undefined(env, &result);
267 return result;
268 }
269
270 // function off(version: number, type: 'change', object: DistributedObject,
271 // callback?: Callback<ChangedDataObserver>): void;
272 // function off(version: number, type: 'status', object: DistributedObject,
273 // callback?: Callback<ObjectStatusObserver>): void;
JSOff(napi_env env,napi_callback_info info)274 napi_value JSDistributedObjectStore::JSOff(napi_env env, napi_callback_info info)
275 {
276 double version = 8;
277 LOG_INFO("start");
278 size_t requireArgc = 3;
279 size_t argc = 4;
280 napi_value argv[4] = { 0 };
281 napi_value thisVar = nullptr;
282 void *data = nullptr;
283 char type[TYPE_SIZE] = { 0 };
284 size_t typeLen = 0;
285 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
286 auto innerError = std::make_shared<InnerError>();
287 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && argc >= 1, version, innerError);
288
289 status = JSUtil::GetValue(env, argv[0], version);
290 NOT_MATCH_RETURN_NULL(status == napi_ok);
291 NAPI_ASSERT_ERRCODE_V9(env, argc >= requireArgc, version, std::make_shared<ParametersNum>("1"));
292
293 status = napi_get_value_string_utf8(env, argv[1], type, TYPE_SIZE, &typeLen);
294 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok, version, std::make_shared<ParametersType>("type", "string"));
295
296 napi_valuetype valueType = napi_undefined;
297 status = napi_typeof(env, argv[2], &valueType);
298 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && valueType == napi_object, version, innerError);
299
300 JSObjectWrapper *wrapper = nullptr;
301 status = napi_unwrap(env, argv[2], (void **)&wrapper);
302 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && wrapper != nullptr, version, innerError);
303 if (argc == requireArgc) {
304 LOG_INFO("delete all");
305 wrapper->DeleteWatch(env, type);
306 } else {
307 LOG_INFO("delete");
308 status = napi_typeof(env, argv[3], &valueType);
309 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && valueType == napi_function, version,
310 std::make_shared<ParametersType>("callback", "function"));
311 wrapper->DeleteWatch(env, type, argv[3]);
312 }
313 napi_value result = nullptr;
314 status = napi_get_undefined(env, &result);
315 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok, version, innerError);
316 return result;
317 }
318
GetBundleNameWithContext(napi_env env,napi_value argv,std::string & bundleName)319 bool JSDistributedObjectStore::GetBundleNameWithContext(napi_env env, napi_value argv, std::string &bundleName)
320 {
321 napi_valuetype objectType = napi_undefined;
322 napi_status status = napi_typeof(env, argv, &objectType);
323 if (status == napi_ok && objectType == napi_object) {
324 std::shared_ptr<Context> context = JSAbility::GetContext(env, argv);
325 if (context != nullptr) {
326 bundleName = context->GetBundleName();
327 return true;
328 }
329 }
330 LOG_ERROR("arguments error, context.");
331 return false;
332 }
333
GetBundleName(napi_env env)334 std::string JSDistributedObjectStore::GetBundleName(napi_env env)
335 {
336 static std::string bundleName;
337 if (bundleName.empty()) {
338 bundleName = AbilityRuntime::Context::GetApplicationContext()->GetBundleName();
339 }
340 return bundleName;
341 }
342
RestoreWatchers(napi_env env,JSObjectWrapper * wrapper,const std::string & objectId)343 void JSDistributedObjectStore::RestoreWatchers(napi_env env, JSObjectWrapper *wrapper, const std::string &objectId)
344 {
345 napi_status status;
346 napi_value callbackValue;
347 bool watchResult = true;
348 LOG_DEBUG("start restore %{public}s", objectId.c_str());
349 watchResult = g_changeCallBacks.ComputeIfPresent(objectId, [&](const std::string &key, std::list<napi_ref> &lists) {
350 for (auto callback : lists) {
351 status = napi_get_reference_value(env, callback, &callbackValue);
352 if (status != napi_ok) {
353 LOG_ERROR("error! %{public}d", status);
354 continue;
355 }
356 wrapper->AddWatch(env, Constants::CHANGE, callbackValue);
357 }
358 return true;
359 });
360 if (!watchResult) {
361 LOG_INFO("no callback %{public}s", objectId.c_str());
362 }
363 watchResult = g_statusCallBacks.ComputeIfPresent(objectId, [&](const std::string &key, std::list<napi_ref> &lists) {
364 for (auto callback : lists) {
365 status = napi_get_reference_value(env, callback, &callbackValue);
366 if (status != napi_ok) {
367 LOG_ERROR("error! %{public}d", status);
368 continue;
369 }
370 wrapper->AddWatch(env, Constants::STATUS, callbackValue);
371 }
372 return true;
373 });
374 if (!watchResult) {
375 LOG_INFO("no status %{public}s", objectId.c_str());
376 }
377 watchResult =
378 g_progressCallBacks.ComputeIfPresent(objectId, [&](const std::string &key, std::list<napi_ref> &lists) {
379 for (auto callback : lists) {
380 status = napi_get_reference_value(env, callback, &callbackValue);
381 if (status != napi_ok) {
382 LOG_ERROR("error! %{public}d", status);
383 continue;
384 }
385 wrapper->AddWatch(env, Constants::PROGRESS, callbackValue);
386 }
387 return true;
388 });
389 if (!watchResult) {
390 LOG_INFO("no status %{public}s", objectId.c_str());
391 }
392 }
393
394 // function recordCallback(version: number, type: 'change', objectId: string,
395 // callback: Callback<ChangedDataObserver>): void;
396 // function recordCallback(version: number, type: 'status', objectId: string,
397 // callback: Callback<ObjectStatusObserver>): void;
JSRecordCallback(napi_env env,napi_callback_info info)398 napi_value JSDistributedObjectStore::JSRecordCallback(napi_env env, napi_callback_info info)
399 {
400 double version = 8;
401 LOG_INFO("start");
402 size_t requireArgc = 4;
403 size_t argc = 4;
404 napi_value argv[4] = { 0 };
405 napi_value thisVar = nullptr;
406 void *data = nullptr;
407 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
408 auto innerError = std::make_shared<InnerError>();
409 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && argc >= 1, version, innerError);
410
411 status = JSUtil::GetValue(env, argv[0], version);
412 NOT_MATCH_RETURN_NULL(status == napi_ok);
413 NAPI_ASSERT_ERRCODE_V9(env, argc >= requireArgc, version, std::make_shared<ParametersNum>("2"));
414
415 char type[TYPE_SIZE] = { 0 };
416 size_t eventTypeLen = 0;
417 status = napi_get_value_string_utf8(env, argv[1], type, TYPE_SIZE, &eventTypeLen);
418 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok, version, std::make_shared<ParametersType>("type", "string"));
419
420 std::string objectId;
421 status = JSUtil::GetValue(env, argv[2], objectId);
422 NOT_MATCH_RETURN_NULL(status == napi_ok);
423
424 napi_valuetype callbackType = napi_undefined;
425 status = napi_typeof(env, argv[3], &callbackType);
426 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && callbackType == napi_function, version,
427 std::make_shared<ParametersType>("callback", "function"));
428
429 bool addResult = true;
430 if (!strcmp(Constants::CHANGE, type)) {
431 addResult = AddCallback(env, g_changeCallBacks, objectId, argv[PARAM_COUNT_MAX]);
432 } else if (!strcmp(Constants::STATUS, type)) {
433 addResult = AddCallback(env, g_statusCallBacks, objectId, argv[PARAM_COUNT_MAX]);
434 } else if (!strcmp(Constants::PROGRESS, type)) {
435 addResult = AddCallback(env, g_progressCallBacks, objectId, argv[PARAM_COUNT_MAX]);
436 }
437 NAPI_ASSERT_ERRCODE_V9(env, addResult, version, innerError);
438 napi_value result = nullptr;
439 napi_get_undefined(env, &result);
440 return result;
441 }
442
443 // function deleteCallback(version: number, type: 'change', objectId: string,
444 // callback?: Callback<ChangedDataObserver>): void;
445 // function deleteCallback(version: number, type: 'status', objectId: string,
446 // callback?: Callback<ObjectStatusObserver>): void;
JSDeleteCallback(napi_env env,napi_callback_info info)447 napi_value JSDistributedObjectStore::JSDeleteCallback(napi_env env, napi_callback_info info)
448 {
449 double version = 8;
450 LOG_INFO("start");
451 size_t requireArgc = 3;
452 size_t argc = 4;
453 napi_value argv[4] = { 0 };
454 napi_value thisVar = nullptr;
455 void *data = nullptr;
456 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
457 auto innerError = std::make_shared<InnerError>();
458 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && argc >= 1, version, innerError);
459
460 status = JSUtil::GetValue(env, argv[0], version);
461 NOT_MATCH_RETURN_NULL(status == napi_ok);
462 NAPI_ASSERT_ERRCODE_V9(env, argc >= requireArgc, version, std::make_shared<ParametersNum>("1 or 2"));
463
464 char type[TYPE_SIZE] = { 0 };
465 size_t eventTypeLen = 0;
466
467 status = napi_get_value_string_utf8(env, argv[1], type, TYPE_SIZE, &eventTypeLen);
468 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok, version, std::make_shared<ParametersType>("type", "string"));
469
470 std::string objectId;
471 status = JSUtil::GetValue(env, argv[2], objectId);
472 NOT_MATCH_RETURN_NULL(status == napi_ok);
473
474 bool delResult = true;
475 if (argc == 3) {
476 if (!strcmp(Constants::CHANGE, type)) {
477 delResult = DelCallback(env, g_changeCallBacks, objectId);
478 } else if (!strcmp(Constants::STATUS, type)) {
479 delResult = DelCallback(env, g_statusCallBacks, objectId);
480 } else if (!strcmp(Constants::PROGRESS, type)) {
481 delResult = DelCallback(env, g_progressCallBacks, objectId);
482 }
483 } else {
484 napi_valuetype callbackType = napi_undefined;
485 status = napi_typeof(env, argv[3], &callbackType);
486 NAPI_ASSERT_ERRCODE_V9(env, status == napi_ok && callbackType == napi_function, version,
487 std::make_shared<ParametersType>("callback", "function"));
488 if (!strcmp(Constants::CHANGE, type)) {
489 delResult = DelCallback(env, g_changeCallBacks, objectId, argv[PARAM_COUNT_MAX]);
490 } else if (!strcmp(Constants::STATUS, type)) {
491 delResult = DelCallback(env, g_statusCallBacks, objectId, argv[PARAM_COUNT_MAX]);
492 } else if (!strcmp(Constants::PROGRESS, type)) {
493 delResult = DelCallback(env, g_progressCallBacks, objectId, argv[PARAM_COUNT_MAX]);
494 }
495 }
496 NAPI_ASSERT_ERRCODE_V9(env, delResult, version, innerError);
497 napi_value result = nullptr;
498 napi_get_undefined(env, &result);
499 return result;
500 }
501
JSEquenceNum(napi_env env,napi_callback_info info)502 napi_value JSDistributedObjectStore::JSEquenceNum(napi_env env, napi_callback_info info)
503 {
504 std::random_device randomDevice;
505 std::uniform_int_distribution<uint32_t> distribution(0, std::numeric_limits<uint32_t>::max());
506 std::string str = std::to_string(distribution(randomDevice));
507 napi_value result = nullptr;
508 napi_status status = napi_create_string_utf8(env, str.c_str(), str.size(), &result);
509 NOT_MATCH_RETURN_NULL(status == napi_ok);
510 return result;
511 }
512
513 // don't create distributed data object while this application is sandbox
IsSandBox()514 bool JSDistributedObjectStore::IsSandBox()
515 {
516 int32_t dlpFlag = Security::AccessToken::AccessTokenKit::GetHapDlpFlag(
517 AbilityRuntime::Context::GetApplicationContext()->GetApplicationInfo()->accessTokenId);
518 if (dlpFlag != 0) {
519 return true;
520 }
521 return false;
522 }
523 } // namespace OHOS::ObjectStore
524