1 /*
2 * Copyright (c) 2023 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 "app_utils.h"
17 #include "json_utils.h"
18 #include "hilog_tag_wrapper.h"
19 #include "nlohmann/json.hpp"
20 #include "parameters.h"
21 #include "scene_board_judgement.h"
22
23 namespace OHOS {
24 namespace AAFwk {
25 namespace {
26 constexpr const char* BUNDLE_NAME_LAUNCHER = "com.ohos.launcher";
27 constexpr const char* BUNDLE_NAME_SCENEBOARD = "com.ohos.sceneboard";
28 constexpr const char* LAUNCHER_ABILITY_NAME = "com.ohos.launcher.MainAbility";
29 constexpr const char* SCENEBOARD_ABILITY_NAME = "com.ohos.sceneboard.MainAbility";
30 constexpr const char* INHERIT_WINDOW_SPLIT_SCREEN_MODE = "persist.sys.abilityms.inherit_window_split_screen_mode";
31 constexpr const char* SUPPORT_ANCO_APP = "persist.sys.abilityms.support_anco_app";
32 constexpr const char* TIMEOUT_UNIT_TIME_RATIO = "persist.sys.abilityms.timeout_unit_time_ratio";
33 constexpr const char* SELECTOR_DIALOG_POSSION = "persist.sys.abilityms.selector_dialog_possion";
34 constexpr const char* START_SPECIFIED_PROCESS = "persist.sys.abilityms.start_specified_process";
35 constexpr const char* USE_MULTI_RENDER_PROCESS = "persist.sys.abilityms.use_multi_render_process";
36 constexpr const char* LIMIT_MAXIMUM_OF_RENDER_PROCESS = "persist.sys.abilityms.limit_maximum_of_render_process";
37 constexpr const char* GRANT_PERSIST_URI_PERMISSION = "persist.sys.abilityms.grant_persist_uri_permission";
38 constexpr const char* START_OPTIONS_WITH_ANIMATION = "persist.sys.abilityms.start_options_with_animation";
39 constexpr const char* MULTI_PROCESS_MODEL = "persist.sys.abilityms.multi_process_model";
40 constexpr const char* START_OPTIONS_WITH_PROCESS_OPTION = "persist.sys.abilityms.start_options_with_process_option";
41 constexpr const char* MOVE_UI_ABILITY_TO_BACKGROUND_API_ENABLE =
42 "persist.sys.abilityms.move_ui_ability_to_background_api_enable";
43 constexpr const char* CONFIG_PATH = "/etc/ability_runtime/resident_process_in_extreme_memory.json";
44 constexpr const char* RESIDENT_PROCESS_IN_EXTREME_MEMORY = "residentProcessInExtremeMemory";
45 constexpr const char* BUNDLE_NAME = "bundleName";
46 constexpr const char* ABILITY_NAME = "abilityName";
47 constexpr const char* KEY_IDENTIFIER = "identifier";
48 constexpr const char* ALLOW_NATIVE_CHILD_PROCESS_APPS_CONFIG_PATH =
49 "/etc/ability_runtime/allow_native_child_process_apps.json";
50 constexpr const char* KEY_ALLOW_NATIVE_CHILD_PROCESS_APPS = "allowNativeChildProcessApps";
51 constexpr const char* LAUNCH_EMBEDED_UI_ABILITY = "const.abilityms.launch_embeded_ui_ability";
52 const std::string SUPPROT_NATIVE_CHILD_PROCESS = "persist.sys.abilityms.start_native_child_process";
53 const std::string LIMIT_MAXIMUM_EXTENSIONS_OF_PER_PROCESS =
54 "const.sys.abilityms.limit_maximum_extensions_of_per_process";
55 const std::string LIMIT_MAXIMUM_EXTENSIONS_OF_PER_DEVICE =
56 "const.sys.abilityms.limit_maximum_extensions_of_per_device";
57 const std::string CACHE_EXTENSION_TYPES = "const.sys.abilityms.cache_extension";
58 constexpr const char* START_ABILITY_WITHOUT_CALLERTOKEN = "/system/etc/start_ability_without_caller_token.json";
59 constexpr const char* START_ABILITY_WITHOUT_CALLERTOKEN_PATH =
60 "/etc/ability_runtime/start_ability_without_caller_token.json";
61 constexpr const char* START_ABILITY_WITHOUT_CALLERTOKEN_TITLE = "startAbilityWithoutCallerToken";
62 constexpr const char* MAX_CHILD_PROCESS = "const.max_native_child_process";
63 constexpr const char* SUPPORT_MULTI_INSTANCE = "const.abilityms.support_multi_instance";
64 constexpr const char* CONNECT_SUPPORT_CROSS_USER = "const.abilityms.connect_support_cross_user";
65 }
66
~AppUtils()67 AppUtils::~AppUtils() {}
68
AppUtils()69 AppUtils::AppUtils()
70 {
71 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
72 isSceneBoard_ = true;
73 }
74 }
75
GetInstance()76 AppUtils &AppUtils::GetInstance()
77 {
78 static AppUtils utils;
79 return utils;
80 }
81
IsLauncher(const std::string & bundleName) const82 bool AppUtils::IsLauncher(const std::string &bundleName) const
83 {
84 if (isSceneBoard_) {
85 return bundleName == BUNDLE_NAME_SCENEBOARD;
86 }
87
88 return bundleName == BUNDLE_NAME_LAUNCHER;
89 }
90
IsLauncherAbility(const std::string & abilityName) const91 bool AppUtils::IsLauncherAbility(const std::string &abilityName) const
92 {
93 if (isSceneBoard_) {
94 return abilityName == SCENEBOARD_ABILITY_NAME;
95 }
96
97 return abilityName == LAUNCHER_ABILITY_NAME;
98 }
99
IsInheritWindowSplitScreenMode()100 bool AppUtils::IsInheritWindowSplitScreenMode()
101 {
102 if (!isInheritWindowSplitScreenMode_.isLoaded) {
103 isInheritWindowSplitScreenMode_.value = system::GetBoolParameter(INHERIT_WINDOW_SPLIT_SCREEN_MODE, true);
104 isInheritWindowSplitScreenMode_.isLoaded = true;
105 }
106 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isInheritWindowSplitScreenMode_.value);
107 return isInheritWindowSplitScreenMode_.value;
108 }
109
IsSupportAncoApp()110 bool AppUtils::IsSupportAncoApp()
111 {
112 if (!isSupportAncoApp_.isLoaded) {
113 isSupportAncoApp_.value = system::GetBoolParameter(SUPPORT_ANCO_APP, false);
114 isSupportAncoApp_.isLoaded = true;
115 }
116 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isSupportAncoApp_.value);
117 return isSupportAncoApp_.value;
118 }
119
GetTimeoutUnitTimeRatio()120 int32_t AppUtils::GetTimeoutUnitTimeRatio()
121 {
122 if (!timeoutUnitTimeRatio_.isLoaded) {
123 timeoutUnitTimeRatio_.value = system::GetIntParameter<int32_t>(TIMEOUT_UNIT_TIME_RATIO, 1);
124 timeoutUnitTimeRatio_.isLoaded = true;
125 }
126 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", timeoutUnitTimeRatio_.value);
127 return timeoutUnitTimeRatio_.value;
128 }
129
IsSelectorDialogDefaultPossion()130 bool AppUtils::IsSelectorDialogDefaultPossion()
131 {
132 if (!isSelectorDialogDefaultPossion_.isLoaded) {
133 isSelectorDialogDefaultPossion_.value = system::GetBoolParameter(SELECTOR_DIALOG_POSSION, true);
134 isSelectorDialogDefaultPossion_.isLoaded = true;
135 }
136 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isSelectorDialogDefaultPossion_.value);
137 return isSelectorDialogDefaultPossion_.value;
138 }
139
IsStartSpecifiedProcess()140 bool AppUtils::IsStartSpecifiedProcess()
141 {
142 if (!isStartSpecifiedProcess_.isLoaded) {
143 isStartSpecifiedProcess_.value = system::GetBoolParameter(START_SPECIFIED_PROCESS, false);
144 isStartSpecifiedProcess_.isLoaded = true;
145 }
146 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isStartSpecifiedProcess_.value);
147 return isStartSpecifiedProcess_.value;
148 }
149
IsUseMultiRenderProcess()150 bool AppUtils::IsUseMultiRenderProcess()
151 {
152 if (!isUseMultiRenderProcess_.isLoaded) {
153 isUseMultiRenderProcess_.value = system::GetBoolParameter(USE_MULTI_RENDER_PROCESS, true);
154 isUseMultiRenderProcess_.isLoaded = true;
155 }
156 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isUseMultiRenderProcess_.value);
157 return isUseMultiRenderProcess_.value;
158 }
159
IsLimitMaximumOfRenderProcess()160 bool AppUtils::IsLimitMaximumOfRenderProcess()
161 {
162 if (!isLimitMaximumOfRenderProcess_.isLoaded) {
163 isLimitMaximumOfRenderProcess_.value = system::GetBoolParameter(LIMIT_MAXIMUM_OF_RENDER_PROCESS, true);
164 isLimitMaximumOfRenderProcess_.isLoaded = true;
165 }
166 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isLimitMaximumOfRenderProcess_.value);
167 return isLimitMaximumOfRenderProcess_.value;
168 }
169
IsGrantPersistUriPermission()170 bool AppUtils::IsGrantPersistUriPermission()
171 {
172 if (!isGrantPersistUriPermission_.isLoaded) {
173 isGrantPersistUriPermission_.value = system::GetBoolParameter(GRANT_PERSIST_URI_PERMISSION, false);
174 isGrantPersistUriPermission_.isLoaded = true;
175 }
176 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isGrantPersistUriPermission_.value);
177 return isGrantPersistUriPermission_.value;
178 }
179
IsStartOptionsWithAnimation()180 bool AppUtils::IsStartOptionsWithAnimation()
181 {
182 if (!isStartOptionsWithAnimation_.isLoaded) {
183 isStartOptionsWithAnimation_.value = system::GetBoolParameter(START_OPTIONS_WITH_ANIMATION, false);
184 isStartOptionsWithAnimation_.isLoaded = true;
185 }
186 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isStartOptionsWithAnimation_.value);
187 return isStartOptionsWithAnimation_.value;
188 }
189
IsMultiProcessModel()190 bool AppUtils::IsMultiProcessModel()
191 {
192 if (!isMultiProcessModel_.isLoaded) {
193 isMultiProcessModel_.value = system::GetBoolParameter(MULTI_PROCESS_MODEL, false);
194 isMultiProcessModel_.isLoaded = true;
195 }
196 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isMultiProcessModel_.value);
197 return isMultiProcessModel_.value;
198 }
199
IsStartOptionsWithProcessOptions()200 bool AppUtils::IsStartOptionsWithProcessOptions()
201 {
202 if (!isStartOptionsWithProcessOptions_.isLoaded) {
203 isStartOptionsWithProcessOptions_.value = system::GetBoolParameter(START_OPTIONS_WITH_PROCESS_OPTION, false);
204 isStartOptionsWithProcessOptions_.isLoaded = true;
205 }
206 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isStartOptionsWithProcessOptions_.value);
207 return isStartOptionsWithProcessOptions_.value;
208 }
209
EnableMoveUIAbilityToBackgroundApi()210 bool AppUtils::EnableMoveUIAbilityToBackgroundApi()
211 {
212 if (!enableMoveUIAbilityToBackgroundApi_.isLoaded) {
213 enableMoveUIAbilityToBackgroundApi_.value =
214 system::GetBoolParameter(MOVE_UI_ABILITY_TO_BACKGROUND_API_ENABLE, true);
215 enableMoveUIAbilityToBackgroundApi_.isLoaded = true;
216 }
217 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", enableMoveUIAbilityToBackgroundApi_.value);
218 return enableMoveUIAbilityToBackgroundApi_.value;
219 }
220
IsLaunchEmbededUIAbility()221 bool AppUtils::IsLaunchEmbededUIAbility()
222 {
223 if (!isLaunchEmbededUIAbility_.isLoaded) {
224 isLaunchEmbededUIAbility_.value = system::GetBoolParameter(LAUNCH_EMBEDED_UI_ABILITY, false);
225 isLaunchEmbededUIAbility_.isLoaded = true;
226 }
227 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isLaunchEmbededUIAbility_.value);
228 return isLaunchEmbededUIAbility_.value;
229 }
230
IsSupportNativeChildProcess()231 bool AppUtils::IsSupportNativeChildProcess()
232 {
233 if (!isSupportNativeChildProcess_.isLoaded) {
234 isSupportNativeChildProcess_.value = system::GetBoolParameter(SUPPROT_NATIVE_CHILD_PROCESS, false);
235 isSupportNativeChildProcess_.isLoaded = true;
236 }
237 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isSupportNativeChildProcess_.value);
238 return isSupportNativeChildProcess_.value;
239 }
240
IsAllowResidentInExtremeMemory(const std::string & bundleName,const std::string & abilityName)241 bool AppUtils::IsAllowResidentInExtremeMemory(const std::string& bundleName, const std::string& abilityName)
242 {
243 std::lock_guard lock(residentProcessInExtremeMemoryMutex_);
244 if (!residentProcessInExtremeMemory_.isLoaded) {
245 LoadResidentProcessInExtremeMemory();
246 residentProcessInExtremeMemory_.isLoaded = true;
247 }
248 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isSupportNativeChildProcess_.value);
249 for (auto &element : residentProcessInExtremeMemory_.value) {
250 if (bundleName == element.first &&
251 (abilityName == "" || abilityName == element.second)) {
252 return true;
253 }
254 }
255 return false;
256 }
257
LoadResidentProcessInExtremeMemory()258 void AppUtils::LoadResidentProcessInExtremeMemory()
259 {
260 nlohmann::json object;
261 if (!JsonUtils::GetInstance().LoadConfiguration(CONFIG_PATH, object)) {
262 TAG_LOGE(AAFwkTag::ABILITYMGR, "resident process failed");
263 return;
264 }
265 if (!object.contains(RESIDENT_PROCESS_IN_EXTREME_MEMORY)) {
266 TAG_LOGE(AAFwkTag::ABILITYMGR, "resident process invalid");
267 return;
268 }
269
270 for (auto &item : object.at(RESIDENT_PROCESS_IN_EXTREME_MEMORY).items()) {
271 const nlohmann::json& jsonObject = item.value();
272 if (!jsonObject.contains(BUNDLE_NAME) || !jsonObject.at(BUNDLE_NAME).is_string()) {
273 TAG_LOGE(AAFwkTag::ABILITYMGR, "load bundleName failed");
274 return;
275 }
276 if (!jsonObject.contains(ABILITY_NAME) || !jsonObject.at(ABILITY_NAME).is_string()) {
277 TAG_LOGE(AAFwkTag::ABILITYMGR, "load abilityName failed");
278 return;
279 }
280 std::string bundleName = jsonObject.at(BUNDLE_NAME).get<std::string>();
281 std::string abilityName = jsonObject.at(ABILITY_NAME).get<std::string>();
282 residentProcessInExtremeMemory_.value.emplace_back(std::make_pair(bundleName, abilityName));
283 }
284 }
285
IsAllowNativeChildProcess(const std::string & appIdentifier)286 bool AppUtils::IsAllowNativeChildProcess(const std::string &appIdentifier)
287 {
288 TAG_LOGD(AAFwkTag::DEFAULT, "appId:%{private}s", appIdentifier.c_str());
289 if (!allowStartNativeProcessApps_.isLoaded) {
290 LoadAllowNativeChildProcessApps();
291 allowStartNativeProcessApps_.isLoaded = true;
292 }
293 auto &apps = allowStartNativeProcessApps_.value;
294 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}zu", apps.size());
295 return std::find(apps.begin(), apps.end(), appIdentifier) != apps.end();
296 }
297
LoadAllowNativeChildProcessApps()298 void AppUtils::LoadAllowNativeChildProcessApps()
299 {
300 nlohmann::json object;
301 if (!JsonUtils::GetInstance().LoadConfiguration(ALLOW_NATIVE_CHILD_PROCESS_APPS_CONFIG_PATH, object)) {
302 TAG_LOGE(AAFwkTag::ABILITYMGR, "load child process config failed");
303 return;
304 }
305 if (!object.contains(KEY_ALLOW_NATIVE_CHILD_PROCESS_APPS)) {
306 TAG_LOGE(AAFwkTag::ABILITYMGR, "get key invalid");
307 return;
308 }
309
310 for (auto &item : object.at(KEY_ALLOW_NATIVE_CHILD_PROCESS_APPS).items()) {
311 const nlohmann::json& jsonObject = item.value();
312 if (!jsonObject.contains(KEY_IDENTIFIER) || !jsonObject.at(KEY_IDENTIFIER).is_string()) {
313 TAG_LOGE(AAFwkTag::ABILITYMGR, "load identifier failed");
314 return;
315 }
316 std::string identifier = jsonObject.at(KEY_IDENTIFIER).get<std::string>();
317 allowStartNativeProcessApps_.value.emplace_back(identifier);
318 }
319 }
320
GetLimitMaximumExtensionsPerProc()321 int32_t AppUtils::GetLimitMaximumExtensionsPerProc()
322 {
323 if (!limitMaximumExtensionsPerProc_.isLoaded) {
324 limitMaximumExtensionsPerProc_.value =
325 system::GetIntParameter<int32_t>(LIMIT_MAXIMUM_EXTENSIONS_OF_PER_PROCESS, DEFAULT_MAX_EXT_PER_PROC);
326 limitMaximumExtensionsPerProc_.isLoaded = true;
327 }
328 TAG_LOGD(AAFwkTag::DEFAULT, "limitMaximumExtensionsPerProc: %{public}d", limitMaximumExtensionsPerProc_.value);
329 return limitMaximumExtensionsPerProc_.value;
330 }
331
GetLimitMaximumExtensionsPerDevice()332 int32_t AppUtils::GetLimitMaximumExtensionsPerDevice()
333 {
334 if (!limitMaximumExtensionsPerDevice_.isLoaded) {
335 limitMaximumExtensionsPerDevice_.value =
336 system::GetIntParameter<int32_t>(LIMIT_MAXIMUM_EXTENSIONS_OF_PER_DEVICE, DEFAULT_MAX_EXT_PER_DEV);
337 limitMaximumExtensionsPerDevice_.isLoaded = true;
338 }
339 TAG_LOGD(AAFwkTag::DEFAULT, "limitMaximumExtensionsPerDevice: %{public}d", limitMaximumExtensionsPerDevice_.value);
340 return limitMaximumExtensionsPerDevice_.value;
341 }
342
GetCacheExtensionTypeList()343 std::string AppUtils::GetCacheExtensionTypeList()
344 {
345 std::string cacheExtAbilityTypeList = system::GetParameter(CACHE_EXTENSION_TYPES, "260");
346 TAG_LOGD(AAFwkTag::DEFAULT, "cacheExtAbilityTypeList is %{public}s", cacheExtAbilityTypeList.c_str());
347 return cacheExtAbilityTypeList;
348 }
349
IsAllowStartAbilityWithoutCallerToken(const std::string & bundleName,const std::string & abilityName)350 bool AppUtils::IsAllowStartAbilityWithoutCallerToken(const std::string& bundleName, const std::string& abilityName)
351 {
352 std::lock_guard lock(startAbilityWithoutCallerTokenMutex_);
353 if (!startAbilityWithoutCallerToken_.isLoaded) {
354 LoadStartAbilityWithoutCallerToken();
355 startAbilityWithoutCallerToken_.isLoaded = true;
356 }
357 TAG_LOGD(AAFwkTag::DEFAULT, "isLoaded: %{public}d", startAbilityWithoutCallerToken_.isLoaded);
358 for (auto &element : startAbilityWithoutCallerToken_.value) {
359 if (bundleName == element.first && abilityName == element.second) {
360 TAG_LOGI(AAFwkTag::DEFAULT, "call");
361 return true;
362 }
363 }
364 return false;
365 }
366
LoadStartAbilityWithoutCallerToken()367 void AppUtils::LoadStartAbilityWithoutCallerToken()
368 {
369 nlohmann::json object;
370 if (!JsonUtils::GetInstance().LoadConfiguration(
371 START_ABILITY_WITHOUT_CALLERTOKEN_PATH, object, START_ABILITY_WITHOUT_CALLERTOKEN)) {
372 TAG_LOGE(AAFwkTag::DEFAULT, "token list failed");
373 return;
374 }
375 if (!object.contains(START_ABILITY_WITHOUT_CALLERTOKEN_TITLE)) {
376 TAG_LOGE(AAFwkTag::DEFAULT, "token config invalid");
377 return;
378 }
379
380 for (auto &item : object.at(START_ABILITY_WITHOUT_CALLERTOKEN_TITLE).items()) {
381 const nlohmann::json& jsonObject = item.value();
382 if (!jsonObject.contains(BUNDLE_NAME) || !jsonObject.at(BUNDLE_NAME).is_string()) {
383 TAG_LOGE(AAFwkTag::DEFAULT, "load bundleName failed");
384 return;
385 }
386 if (!jsonObject.contains(ABILITY_NAME) || !jsonObject.at(ABILITY_NAME).is_string()) {
387 TAG_LOGE(AAFwkTag::DEFAULT, "load abilityName failed");
388 return;
389 }
390 std::string bundleName = jsonObject.at(BUNDLE_NAME).get<std::string>();
391 std::string abilityName = jsonObject.at(ABILITY_NAME).get<std::string>();
392 startAbilityWithoutCallerToken_.value.emplace_back(std::make_pair(bundleName, abilityName));
393 }
394 }
395
MaxChildProcess()396 int32_t AppUtils::MaxChildProcess()
397 {
398 if (!maxChildProcess_.isLoaded) {
399 maxChildProcess_.value =
400 system::GetIntParameter<int32_t>(MAX_CHILD_PROCESS, DEFAULT_MAX_CHILD_PROCESS);
401 maxChildProcess_.isLoaded = true;
402 }
403 TAG_LOGD(AAFwkTag::DEFAULT, "MaxChildProcess: %{public}d", maxChildProcess_.value);
404 return maxChildProcess_.value;
405 }
406
IsSupportMultiInstance()407 bool AppUtils::IsSupportMultiInstance()
408 {
409 if (!isSupportMultiInstance_.isLoaded) {
410 isSupportMultiInstance_.value = system::GetBoolParameter(SUPPORT_MULTI_INSTANCE, false);
411 isSupportMultiInstance_.isLoaded = true;
412 }
413 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isSupportMultiInstance_.value);
414 return isSupportMultiInstance_.value;
415 }
416
IsConnectSupportCrossUser()417 bool AppUtils::IsConnectSupportCrossUser()
418 {
419 std::lock_guard guard(isConnectSupportCrossUserMutex_);
420 if (!isConnectSupportCrossUser_.isLoaded) {
421 isConnectSupportCrossUser_.value = system::GetBoolParameter(CONNECT_SUPPORT_CROSS_USER, false);
422 isConnectSupportCrossUser_.isLoaded = true;
423 }
424 TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isConnectSupportCrossUser_.value);
425 return isConnectSupportCrossUser_.value;
426 }
427 } // namespace AAFwk
428 } // namespace OHOS
429