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