1 /*
2 * Copyright (c) 2023-2024 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 "dialog_session_manager.h"
17
18 #include <random>
19 #include "ability_manager_service.h"
20 #include "ability_util.h"
21 #include "hitrace_meter.h"
22 #include "int_wrapper.h"
23 #include "modal_system_ui_extension.h"
24 #include "start_ability_utils.h"
25 #include "string_wrapper.h"
26 #include "want.h"
27
28 namespace OHOS {
29 namespace AAFwk {
30 using OHOS::AppExecFwk::BundleInfo;
31 namespace {
32 constexpr const char* UIEXTENSION_MODAL_TYPE = "ability.want.params.modalType";
33 constexpr int32_t ERMS_ISALLOW_RESULTCODE = 10;
34 constexpr const char* SUPPORT_CLOSE_ON_BLUR = "supportCloseOnBlur";
35 constexpr const char* DIALOG_SESSION_ID = "dialogSessionId";
36 }
37
GetInstance()38 DialogSessionManager &DialogSessionManager::GetInstance()
39 {
40 static DialogSessionManager instance;
41 return instance;
42 }
43
GenerateDialogSessionId()44 std::string DialogSessionManager::GenerateDialogSessionId()
45 {
46 auto timestamp = std::chrono::system_clock::now().time_since_epoch();
47 auto time = std::chrono::duration_cast<std::chrono::seconds>(timestamp).count();
48 std::random_device seed;
49 std::mt19937 rng(seed());
50 std::uniform_int_distribution<int> uni(0, INT_MAX);
51 int randomDigit = uni(rng);
52 std::string dialogSessionId = std::to_string(time) + "_" + std::to_string(randomDigit);
53
54 std::lock_guard<ffrt::mutex> guard(dialogSessionRecordLock_);
55 auto iter = dialogSessionInfoMap_.find(dialogSessionId);
56 while (iter != dialogSessionInfoMap_.end()) {
57 dialogSessionId += "_1";
58 iter = dialogSessionInfoMap_.find(dialogSessionId);
59 }
60 return dialogSessionId;
61 }
62
SetStartupSessionInfo(const std::string & dialogSessionId,const AbilityRequest & abilityRequest)63 void DialogSessionManager::SetStartupSessionInfo(const std::string &dialogSessionId,
64 const AbilityRequest &abilityRequest)
65 {
66 std::lock_guard<ffrt::mutex> guard(dialogSessionRecordLock_);
67 std::shared_ptr<StartupSessionInfo> startupSessionInfo = std::make_shared<StartupSessionInfo>();
68 startupSessionInfo->abilityRequest = abilityRequest;
69 startupSessionInfoMap_[dialogSessionId] = startupSessionInfo;
70 }
71
SetDialogSessionInfo(const std::string & dialogSessionId,sptr<DialogSessionInfo> & dilogSessionInfo,std::shared_ptr<DialogCallerInfo> & dialogCallerInfo)72 void DialogSessionManager::SetDialogSessionInfo(const std::string &dialogSessionId,
73 sptr<DialogSessionInfo> &dilogSessionInfo, std::shared_ptr<DialogCallerInfo> &dialogCallerInfo)
74 {
75 std::lock_guard<ffrt::mutex> guard(dialogSessionRecordLock_);
76 dialogSessionInfoMap_[dialogSessionId] = dilogSessionInfo;
77 dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
78 }
79
GetDialogSessionInfo(const std::string & dialogSessionId) const80 sptr<DialogSessionInfo> DialogSessionManager::GetDialogSessionInfo(const std::string &dialogSessionId) const
81 {
82 std::lock_guard<ffrt::mutex> guard(dialogSessionRecordLock_);
83 auto it = dialogSessionInfoMap_.find(dialogSessionId);
84 if (it != dialogSessionInfoMap_.end()) {
85 return it->second;
86 }
87 TAG_LOGI(AAFwkTag::DIALOG, "not find");
88 return nullptr;
89 }
90
GetDialogCallerInfo(const std::string & dialogSessionId) const91 std::shared_ptr<DialogCallerInfo> DialogSessionManager::GetDialogCallerInfo(const std::string &dialogSessionId) const
92 {
93 std::lock_guard<ffrt::mutex> guard(dialogSessionRecordLock_);
94 auto it = dialogCallerInfoMap_.find(dialogSessionId);
95 if (it != dialogCallerInfoMap_.end()) {
96 return it->second;
97 }
98 TAG_LOGI(AAFwkTag::DIALOG, "not find");
99 return nullptr;
100 }
101
GetStartupSessionInfo(const std::string & dialogSessionId) const102 std::shared_ptr<StartupSessionInfo> DialogSessionManager::GetStartupSessionInfo(
103 const std::string &dialogSessionId) const
104 {
105 std::lock_guard<ffrt::mutex> guard(dialogSessionRecordLock_);
106 auto it = startupSessionInfoMap_.find(dialogSessionId);
107 if (it != startupSessionInfoMap_.end()) {
108 return it->second;
109 }
110 TAG_LOGI(AAFwkTag::DIALOG, "not find");
111 return nullptr;
112 }
113
ClearDialogContext(const std::string & dialogSessionId)114 void DialogSessionManager::ClearDialogContext(const std::string &dialogSessionId)
115 {
116 std::lock_guard<ffrt::mutex> guard(dialogSessionRecordLock_);
117 dialogSessionInfoMap_.erase(dialogSessionId);
118 dialogCallerInfoMap_.erase(dialogSessionId);
119 startupSessionInfoMap_.erase(dialogSessionId);
120 return;
121 }
122
ClearAllDialogContexts()123 void DialogSessionManager::ClearAllDialogContexts()
124 {
125 std::lock_guard<ffrt::mutex> guard(dialogSessionRecordLock_);
126 dialogSessionInfoMap_.clear();
127 dialogCallerInfoMap_.clear();
128 startupSessionInfoMap_.clear();
129 }
130
GenerateCallerAbilityInfo(AbilityRequest & abilityRequest,DialogAbilityInfo & callerAbilityInfo)131 void DialogSessionManager::GenerateCallerAbilityInfo(AbilityRequest &abilityRequest,
132 DialogAbilityInfo &callerAbilityInfo)
133 {
134 sptr<IRemoteObject> callerToken = abilityRequest.callerToken;
135 if (callerToken != nullptr) {
136 auto callerRecord = Token::GetAbilityRecordByToken(callerToken);
137 CHECK_POINTER(callerRecord);
138 callerAbilityInfo.bundleName = callerRecord->GetAbilityInfo().bundleName;
139 callerAbilityInfo.moduleName = callerRecord->GetAbilityInfo().moduleName;
140 callerAbilityInfo.abilityName = callerRecord->GetAbilityInfo().name;
141 callerAbilityInfo.abilityIconId = callerRecord->GetAbilityInfo().iconId;
142 callerAbilityInfo.abilityLabelId = callerRecord->GetAbilityInfo().labelId;
143 callerAbilityInfo.bundleIconId = callerRecord->GetApplicationInfo().iconId;
144 callerAbilityInfo.bundleLabelId = callerRecord->GetApplicationInfo().labelId;
145 callerAbilityInfo.visible = callerRecord->GetAbilityInfo().visible;
146 callerAbilityInfo.appIndex = callerRecord->GetApplicationInfo().appIndex;
147 callerAbilityInfo.multiAppMode = callerRecord->GetApplicationInfo().multiAppMode;
148 }
149 }
150
GenerateSelectorTargetAbilityInfos(std::vector<DialogAppInfo> & dialogAppInfos,std::vector<DialogAbilityInfo> & targetAbilityInfos)151 void DialogSessionManager::GenerateSelectorTargetAbilityInfos(std::vector<DialogAppInfo> &dialogAppInfos,
152 std::vector<DialogAbilityInfo> &targetAbilityInfos)
153 {
154 for (auto &dialogAppInfo : dialogAppInfos) {
155 DialogAbilityInfo targetDialogAbilityInfo;
156 targetDialogAbilityInfo.bundleName = dialogAppInfo.bundleName;
157 targetDialogAbilityInfo.moduleName = dialogAppInfo.moduleName;
158 targetDialogAbilityInfo.abilityName = dialogAppInfo.abilityName;
159 targetDialogAbilityInfo.abilityIconId = dialogAppInfo.abilityIconId;
160 targetDialogAbilityInfo.abilityLabelId = dialogAppInfo.abilityLabelId;
161 targetDialogAbilityInfo.bundleIconId = dialogAppInfo.bundleIconId;
162 targetDialogAbilityInfo.bundleLabelId = dialogAppInfo.bundleLabelId;
163 targetDialogAbilityInfo.visible = dialogAppInfo.visible;
164 targetDialogAbilityInfo.appIndex = dialogAppInfo.appIndex;
165 targetDialogAbilityInfo.multiAppMode = dialogAppInfo.multiAppMode;
166 targetAbilityInfos.emplace_back(targetDialogAbilityInfo);
167 }
168 }
169
GenerateJumpTargetAbilityInfos(AbilityRequest & abilityRequest,std::vector<DialogAbilityInfo> & targetAbilityInfos)170 void DialogSessionManager::GenerateJumpTargetAbilityInfos(AbilityRequest &abilityRequest,
171 std::vector<DialogAbilityInfo> &targetAbilityInfos)
172 {
173 DialogAbilityInfo targetDialogAbilityInfo;
174 targetDialogAbilityInfo.bundleName = abilityRequest.abilityInfo.bundleName;
175 targetDialogAbilityInfo.moduleName = abilityRequest.abilityInfo.moduleName;
176 targetDialogAbilityInfo.abilityName = abilityRequest.abilityInfo.name;
177 targetDialogAbilityInfo.abilityIconId = abilityRequest.abilityInfo.iconId;
178 targetDialogAbilityInfo.abilityLabelId = abilityRequest.abilityInfo.labelId;
179 targetDialogAbilityInfo.bundleIconId = abilityRequest.abilityInfo.applicationInfo.iconId;
180 targetDialogAbilityInfo.bundleLabelId = abilityRequest.abilityInfo.applicationInfo.labelId;
181 targetDialogAbilityInfo.visible = abilityRequest.abilityInfo.visible;
182 targetDialogAbilityInfo.appIndex = abilityRequest.abilityInfo.applicationInfo.appIndex;
183 targetDialogAbilityInfo.multiAppMode = abilityRequest.abilityInfo.applicationInfo.multiAppMode;
184 targetAbilityInfos.emplace_back(targetDialogAbilityInfo);
185 }
186
GenerateDialogCallerInfo(AbilityRequest & abilityRequest,int32_t userId,std::shared_ptr<DialogCallerInfo> dialogCallerInfo,SelectorType type)187 void DialogSessionManager::GenerateDialogCallerInfo(AbilityRequest &abilityRequest, int32_t userId,
188 std::shared_ptr<DialogCallerInfo> dialogCallerInfo, SelectorType type)
189 {
190 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
191 CHECK_POINTER(dialogCallerInfo);
192 dialogCallerInfo->type = type;
193 dialogCallerInfo->callerToken = abilityRequest.callerToken;
194 dialogCallerInfo->requestCode = abilityRequest.requestCode;
195 dialogCallerInfo->targetWant = abilityRequest.want;
196 dialogCallerInfo->userId = userId;
197 }
198
SendDialogResult(const Want & want,const std::string & dialogSessionId,bool isAllowed)199 int DialogSessionManager::SendDialogResult(const Want &want, const std::string &dialogSessionId, bool isAllowed)
200 {
201 if (!isAllowed) {
202 TAG_LOGI(AAFwkTag::ABILITYMGR, "user refuse to jump");
203 ClearDialogContext(dialogSessionId);
204 return ERR_OK;
205 }
206 std::shared_ptr<StartupSessionInfo> startupSessionInfo = GetStartupSessionInfo(dialogSessionId);
207 if (startupSessionInfo != nullptr) {
208 return NotifySCBToRecoveryAfterInterception(dialogSessionId, startupSessionInfo->abilityRequest);
209 }
210 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = GetDialogCallerInfo(dialogSessionId);
211 if (dialogCallerInfo == nullptr) {
212 TAG_LOGE(AAFwkTag::ABILITYMGR, "dialog caller info is nullptr");
213 ClearDialogContext(dialogSessionId);
214 return ERR_INVALID_VALUE;
215 }
216 auto targetWant = dialogCallerInfo->targetWant;
217 targetWant.SetElement(want.GetElement());
218 targetWant.SetParam("isSelector", dialogCallerInfo->type != SelectorType::WITHOUT_SELECTOR);
219 targetWant.SetParam(DIALOG_SESSION_ID, dialogSessionId);
220 if (want.HasParameter(AAFwk::Want::PARAM_APP_CLONE_INDEX_KEY)) {
221 int32_t appIndex = want.GetIntParam(AAFwk::Want::PARAM_APP_CLONE_INDEX_KEY, 0);
222 targetWant.SetParam(AAFwk::Want::PARAM_APP_CLONE_INDEX_KEY, appIndex);
223 }
224 if (!targetWant.HasParameter(AAFwk::Want::PARAM_APP_CLONE_INDEX_KEY)) {
225 targetWant.SetParam(AAFwk::Want::PARAM_APP_CLONE_INDEX_KEY, 0);
226 }
227 sptr<IRemoteObject> callerToken = dialogCallerInfo->callerToken;
228 auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
229 if (!abilityMgr) {
230 TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityMgr is nullptr.");
231 return INNER_ERR;
232 }
233 int ret = abilityMgr->StartAbilityAsCallerDetails(targetWant, callerToken, callerToken, dialogCallerInfo->userId,
234 dialogCallerInfo->requestCode, false, dialogCallerInfo->type == SelectorType::APP_CLONE_SELECTOR);
235 if (ret == ERR_OK) {
236 ClearDialogContext(dialogSessionId);
237 abilityMgr->RemoveSelectorIdentity(dialogCallerInfo->targetWant.GetIntParam(Want::PARAM_RESV_CALLER_TOKEN, 0));
238 }
239 return ret;
240 }
241
NotifySCBToRecoveryAfterInterception(const std::string & dialogSessionId,const AbilityRequest & abilityRequest)242 int32_t DialogSessionManager::NotifySCBToRecoveryAfterInterception(const std::string &dialogSessionId,
243 const AbilityRequest &abilityRequest)
244 {
245 auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
246 if (!abilityMgr) {
247 TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityMgr is nullptr.");
248 return INNER_ERR;
249 }
250 int ret = IN_PROCESS_CALL(abilityMgr->NotifySCBToRecoveryAfterInterception(abilityRequest));
251 if (ret == ERR_OK) {
252 ClearDialogContext(dialogSessionId);
253 }
254 return ret;
255 }
256
GenerateDialogSessionRecordCommon(AbilityRequest & abilityRequest,int32_t userId,const AAFwk::WantParams & parameters,std::vector<DialogAppInfo> & dialogAppInfos,SelectorType type)257 std::string DialogSessionManager::GenerateDialogSessionRecordCommon(AbilityRequest &abilityRequest, int32_t userId,
258 const AAFwk::WantParams ¶meters, std::vector<DialogAppInfo> &dialogAppInfos, SelectorType type)
259 {
260 auto dialogSessionInfo = sptr<DialogSessionInfo>::MakeSptr();
261 CHECK_POINTER_AND_RETURN(dialogSessionInfo, "");
262
263 GenerateCallerAbilityInfo(abilityRequest, dialogSessionInfo->callerAbilityInfo);
264
265 if (type != SelectorType::WITHOUT_SELECTOR) {
266 GenerateSelectorTargetAbilityInfos(dialogAppInfos, dialogSessionInfo->targetAbilityInfos);
267 } else {
268 GenerateJumpTargetAbilityInfos(abilityRequest, dialogSessionInfo->targetAbilityInfos);
269 }
270
271 dialogSessionInfo->parameters = parameters;
272
273 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
274 GenerateDialogCallerInfo(abilityRequest, userId, dialogCallerInfo, type);
275
276 std::string dialogSessionId = GenerateDialogSessionId();
277 SetDialogSessionInfo(dialogSessionId, dialogSessionInfo, dialogCallerInfo);
278
279 return dialogSessionId;
280 }
281
CreateJumpModalDialog(AbilityRequest & abilityRequest,int32_t userId,const Want & replaceWant)282 int DialogSessionManager::CreateJumpModalDialog(AbilityRequest &abilityRequest, int32_t userId,
283 const Want &replaceWant)
284 {
285 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
286
287 AAFwk::WantParams parameters;
288
289 parameters.SetParam("deviceType", AAFwk::String::Box(OHOS::system::GetDeviceType()));
290 parameters.SetParam("userId", AAFwk::Integer::Box(userId));
291
292 std::vector<DialogAppInfo> dialogAppInfos;
293 std::string dialogSessionId = GenerateDialogSessionRecordCommon(abilityRequest, userId, parameters,
294 dialogAppInfos, SelectorType::WITHOUT_SELECTOR);
295 if (dialogSessionId == "") {
296 TAG_LOGE(AAFwkTag::ABILITYMGR, "generate dialog session record failed");
297 return ERR_INVALID_VALUE;
298 }
299
300 return CreateModalDialogCommon(replaceWant, abilityRequest.callerToken, dialogSessionId);
301 }
302
CreateImplicitSelectorModalDialog(AbilityRequest & abilityRequest,const Want & want,int32_t userId,std::vector<DialogAppInfo> & dialogAppInfos)303 int DialogSessionManager::CreateImplicitSelectorModalDialog(AbilityRequest &abilityRequest, const Want &want,
304 int32_t userId, std::vector<DialogAppInfo> &dialogAppInfos)
305 {
306 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
307
308 AAFwk::Want sessionWant;
309
310 sessionWant.SetParam("deviceType", OHOS::system::GetDeviceType());
311 sessionWant.SetParam("userId", userId);
312 sessionWant.SetParam("action", abilityRequest.want.GetAction());
313 sessionWant.SetParam("wantType", abilityRequest.want.GetType());
314 sessionWant.SetParam("uri", abilityRequest.want.GetUriString());
315 sessionWant.SetParam("entities", abilityRequest.want.GetEntities());
316 sessionWant.SetParam("appselector.selectorType", static_cast<int>(SelectorType::IMPLICIT_START_SELECTOR));
317 bool showCaller = abilityRequest.want.GetBoolParam("showCaller", false);
318 sessionWant.SetParam("showCaller", showCaller);
319 sessionWant.SetParam("ohos.ability.param.showDefaultPicker",
320 abilityRequest.want.GetBoolParam("ohos.ability.params.showDefaultPicker", false));
321
322 std::string dialogSessionId = GenerateDialogSessionRecordCommon(abilityRequest, userId, sessionWant.GetParams(),
323 dialogAppInfos, SelectorType::IMPLICIT_START_SELECTOR);
324 if (dialogSessionId == "") {
325 TAG_LOGE(AAFwkTag::ABILITYMGR, "generate dialog session record failed");
326 return ERR_INVALID_VALUE;
327 }
328
329 return CreateModalDialogCommon(want, abilityRequest.callerToken, dialogSessionId);
330 }
331
CreateCloneSelectorModalDialog(AbilityRequest & abilityRequest,const Want & want,int32_t userId,std::vector<DialogAppInfo> & dialogAppInfos,const std::string & replaceWant)332 int DialogSessionManager::CreateCloneSelectorModalDialog(AbilityRequest &abilityRequest, const Want &want,
333 int32_t userId, std::vector<DialogAppInfo> &dialogAppInfos, const std::string &replaceWant)
334 {
335 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
336 AAFwk::WantParams parameters;
337
338 parameters.SetParam("deviceType", AAFwk::String::Box(OHOS::system::GetDeviceType()));
339 parameters.SetParam("userId", AAFwk::Integer::Box(userId));
340 parameters.SetParam("appselector.selectorType",
341 AAFwk::Integer::Box(static_cast<int>(SelectorType::APP_CLONE_SELECTOR)));
342 if (replaceWant != "") {
343 parameters.SetParam("ecological.replaceWant", AAFwk::String::Box(replaceWant));
344 }
345
346 std::string dialogSessionId = GenerateDialogSessionRecordCommon(abilityRequest, userId, parameters,
347 dialogAppInfos, SelectorType::APP_CLONE_SELECTOR);
348 if (dialogSessionId == "") {
349 TAG_LOGE(AAFwkTag::ABILITYMGR, "generate dialog session record failed");
350 return ERR_INVALID_VALUE;
351 }
352
353 return CreateModalDialogCommon(want, abilityRequest.callerToken, dialogSessionId);
354 }
355
CreateModalDialogCommon(const Want & replaceWant,sptr<IRemoteObject> callerToken,const std::string & dialogSessionId)356 int DialogSessionManager::CreateModalDialogCommon(const Want &replaceWant, sptr<IRemoteObject> callerToken,
357 const std::string &dialogSessionId)
358 {
359 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
360 (const_cast<Want &>(replaceWant)).SetParam(DIALOG_SESSION_ID, dialogSessionId);
361 auto connection = std::make_shared<OHOS::Rosen::ModalSystemUiExtension>();
362 if (callerToken == nullptr) {
363 TAG_LOGD(AAFwkTag::ABILITYMGR, "create modal ui extension for system");
364 (const_cast<Want &>(replaceWant)).SetParam(UIEXTENSION_MODAL_TYPE, 1);
365 (const_cast<Want &>(replaceWant)).SetParam(SUPPORT_CLOSE_ON_BLUR, true);
366 return IN_PROCESS_CALL(connection->CreateModalUIExtension(replaceWant)) ? ERR_OK : INNER_ERR;
367 }
368 auto callerRecord = Token::GetAbilityRecordByToken(callerToken);
369 if (!callerRecord) {
370 TAG_LOGE(AAFwkTag::ABILITYMGR, "callerRecord is nullptr.");
371 return ERR_INVALID_VALUE;
372 }
373
374 sptr<IRemoteObject> token;
375 auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
376 if (!abilityMgr) {
377 TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityMgr is nullptr.");
378 return INNER_ERR;
379 }
380 int ret = IN_PROCESS_CALL(abilityMgr->GetTopAbility(token));
381 if (ret != ERR_OK || token == nullptr) {
382 TAG_LOGD(AAFwkTag::ABILITYMGR, "create modal ui extension for system");
383 (const_cast<Want &>(replaceWant)).SetParam(UIEXTENSION_MODAL_TYPE, 1);
384 (const_cast<Want &>(replaceWant)).SetParam(SUPPORT_CLOSE_ON_BLUR, true);
385 return IN_PROCESS_CALL(connection->CreateModalUIExtension(replaceWant)) ? ERR_OK : INNER_ERR;
386 }
387
388 if (callerRecord->GetAbilityInfo().type == AppExecFwk::AbilityType::PAGE && token == callerToken) {
389 TAG_LOGD(AAFwkTag::ABILITYMGR, "create modal ui extension for application");
390 return callerRecord->CreateModalUIExtension(replaceWant);
391 }
392 TAG_LOGD(AAFwkTag::ABILITYMGR, "create modal ui extension for system");
393 (const_cast<Want &>(replaceWant)).SetParam(UIEXTENSION_MODAL_TYPE, 1);
394 (const_cast<Want &>(replaceWant)).SetParam(SUPPORT_CLOSE_ON_BLUR, true);
395 return IN_PROCESS_CALL(connection->CreateModalUIExtension(replaceWant)) ? ERR_OK : INNER_ERR;
396 }
397
HandleErmsResult(AbilityRequest & abilityRequest,int32_t userId,const Want & replaceWant)398 int DialogSessionManager::HandleErmsResult(AbilityRequest &abilityRequest, int32_t userId,
399 const Want &replaceWant)
400 {
401 std::string bundleName = abilityRequest.abilityInfo.bundleName;
402 if (StartAbilityUtils::ermsResultCode < ERMS_ISALLOW_RESULTCODE ||
403 !IsCreateCloneSelectorDialog(bundleName, userId)) {
404 TAG_LOGI(AAFwkTag::ABILITYMGR, "create jump modal dialog");
405 return CreateJumpModalDialog(abilityRequest, userId, replaceWant);
406 }
407 auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
408 if (!abilityMgr) {
409 TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityMgr is nullptr.");
410 return INNER_ERR;
411 }
412 (const_cast<Want &>(replaceWant)).RemoveParam("ecological_experience_original_target");
413 return abilityMgr->CreateCloneSelectorDialog(abilityRequest, userId, replaceWant.ToString());
414 }
415
HandleErmsResultBySCB(AbilityRequest & abilityRequest,const Want & replaceWant)416 int32_t DialogSessionManager::HandleErmsResultBySCB(AbilityRequest &abilityRequest, const Want &replaceWant)
417 {
418 auto systemUIExtension = std::make_shared<OHOS::Rosen::ModalSystemUiExtension>();
419 (const_cast<Want &>(replaceWant)).SetParam(UIEXTENSION_MODAL_TYPE, 1);
420 (const_cast<Want &>(replaceWant)).SetParam(SUPPORT_CLOSE_ON_BLUR, true);
421 std::string dialogSessionId = GenerateDialogSessionId();
422 if (dialogSessionId == "") {
423 TAG_LOGE(AAFwkTag::ABILITYMGR, "generate dialog session record failed");
424 return ERR_INVALID_VALUE;
425 }
426 SetStartupSessionInfo(dialogSessionId, abilityRequest);
427 (const_cast<Want &>(replaceWant)).SetParam(DIALOG_SESSION_ID, dialogSessionId);
428 return IN_PROCESS_CALL(systemUIExtension->CreateModalUIExtension(replaceWant)) ?
429 ERR_ECOLOGICAL_CONTROL_STATUS : INNER_ERR;
430 }
431
IsCreateCloneSelectorDialog(const std::string & bundleName,int32_t userId)432 bool DialogSessionManager::IsCreateCloneSelectorDialog(const std::string &bundleName, int32_t userId)
433 {
434 if (StartAbilityUtils::isWantWithAppCloneIndex) {
435 TAG_LOGI(AAFwkTag::ABILITYMGR, "want with app clone index.");
436 StartAbilityUtils::isWantWithAppCloneIndex = false;
437 return false;
438 }
439 auto appIndexes = StartAbilityUtils::GetCloneAppIndexes(bundleName, userId);
440 if (appIndexes.empty()) {
441 TAG_LOGI(AAFwkTag::ABILITYMGR, "The application do not create clone index.");
442 return false;
443 }
444 return true;
445 }
446 } // namespace AAFwk
447 } // namespace OHOS
448