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