1 /*
2  * Copyright (c) 2022-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 #include "implicit_start_processor.h"
16 
17 #include "ability_manager_service.h"
18 #include "ability_util.h"
19 #include "app_utils.h"
20 #include "dialog_session_manager.h"
21 #include "ecological_rule/ability_ecological_rule_mgr_service.h"
22 #include "global_constant.h"
23 #include "hitrace_meter.h"
24 #include "start_ability_utils.h"
25 #include "startup_util.h"
26 #ifdef WITH_DLP
27 #include "dlp_file_kits.h"
28 #endif // WITH_DLP
29 
30 namespace OHOS {
31 namespace AAFwk {
32 const size_t IDENTITY_LIST_MAX_SIZE = 10;
33 
34 const std::string BLACK_ACTION_SELECT_DATA = "ohos.want.action.select";
35 const std::string ACTION_VIEW = "ohos.want.action.viewData";
36 const std::string STR_PHONE = "phone";
37 const std::string STR_DEFAULT = "default";
38 const std::string TYPE_ONLY_MATCH_WILDCARD = "reserved/wildcard";
39 const std::string SHOW_DEFAULT_PICKER_FLAG = "ohos.ability.params.showDefaultPicker";
40 const std::string PARAM_ABILITY_APPINFOS = "ohos.ability.params.appInfos";
41 const std::string ANCO_PENDING_REQUEST = "ancoPendingRequest";
42 const int NFC_CALLER_UID = 1027;
43 const int NFC_QUERY_LENGTH = 2;
44 const std::string OPEN_LINK_APP_LINKING_ONLY = "appLinkingOnly";
45 const std::string HTTP_SCHEME_NAME = "http";
46 const std::string HTTPS_SCHEME_NAME = "https";
47 const std::string APP_CLONE_INDEX = "ohos.extra.param.key.appCloneIndex";
48 constexpr const char* SUPPORT_ACTION_START_SELECTOR = "persist.sys.ability.support.action_start_selector";
49 
SendAbilityEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)50 void SendAbilityEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
51 {
52     auto instance_ = DelayedSingleton<AbilityManagerService>::GetInstance();
53     if (instance_ == nullptr) {
54         TAG_LOGE(AAFwkTag::ABILITYMGR, "instance null.");
55         return;
56     }
57     auto taskHandler = instance_->GetTaskHandler();
58     if (taskHandler == nullptr) {
59         TAG_LOGI(AAFwkTag::ABILITYMGR, "task handler null.");
60         return;
61     }
62     taskHandler->SubmitTask([eventName, type, eventInfo]() {
63         EventReport::SendAbilityEvent(eventName, type, eventInfo);
64     });
65 }
66 
IsExtensionInWhiteList(AppExecFwk::ExtensionAbilityType type)67 bool ImplicitStartProcessor::IsExtensionInWhiteList(AppExecFwk::ExtensionAbilityType type)
68 {
69     switch (type) {
70         case AppExecFwk::ExtensionAbilityType::FORM: return true;
71         case AppExecFwk::ExtensionAbilityType::INPUTMETHOD: return true;
72         case AppExecFwk::ExtensionAbilityType::WALLPAPER: return true;
73         case AppExecFwk::ExtensionAbilityType::WINDOW: return true;
74         case AppExecFwk::ExtensionAbilityType::THUMBNAIL: return true;
75         case AppExecFwk::ExtensionAbilityType::PREVIEW: return true;
76         default: return false;
77     }
78 }
79 
IsImplicitStartAction(const Want &want)80 bool ImplicitStartProcessor::IsImplicitStartAction(const Want &want)
81 {
82     auto element = want.GetElement();
83     if (!element.GetAbilityName().empty()) {
84         return false;
85     }
86 
87     if (want.GetIntParam(AAFwk::SCREEN_MODE_KEY, ScreenMode::IDLE_SCREEN_MODE) != ScreenMode::IDLE_SCREEN_MODE) {
88         TAG_LOGI(AAFwkTag::ABILITYMGR, "not use implicit startup process");
89         return false;
90     }
91 
92     if (want.GetAction() != BLACK_ACTION_SELECT_DATA) {
93         TAG_LOGI(AAFwkTag::ABILITYMGR, "implicit start, action:%{public}s", want.GetAction().data());
94         return true;
95     }
96 
97     return false;
98 }
99 
CheckImplicitCallPermission(const AbilityRequest& abilityRequest)100 int ImplicitStartProcessor::CheckImplicitCallPermission(const AbilityRequest& abilityRequest)
101 {
102     auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
103     CHECK_POINTER_AND_RETURN(abilityMgr, ERR_INVALID_VALUE);
104     bool isBackgroundCall = true;
105     if (abilityMgr->IsCallFromBackground(abilityRequest, isBackgroundCall) != ERR_OK) {
106         return ERR_INVALID_VALUE;
107     }
108     if (!isBackgroundCall) {
109         TAG_LOGD(AAFwkTag::ABILITYMGR, "hap not background");
110         return ERR_OK;
111     }
112     auto ret = AAFwk::PermissionVerification::GetInstance()->VerifyBackgroundCallPermission(isBackgroundCall);
113     if (!ret) {
114         TAG_LOGE(AAFwkTag::ABILITYMGR, "CheckImplicitCallPermission failed");
115         return CHECK_PERMISSION_FAILED;
116     }
117     return ERR_OK;
118 }
119 
ImplicitStartAbility(AbilityRequest &request, int32_t userId, int32_t windowMode, const std::string &replaceWantString, bool isAppCloneSelector)120 int ImplicitStartProcessor::ImplicitStartAbility(AbilityRequest &request, int32_t userId, int32_t windowMode,
121     const std::string &replaceWantString, bool isAppCloneSelector)
122 {
123     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
124     TAG_LOGI(AAFwkTag::ABILITYMGR, "implicit start ability by type: %{public}d", request.callType);
125     auto sysDialogScheduler = DelayedSingleton<SystemDialogScheduler>::GetInstance();
126     CHECK_POINTER_AND_RETURN(sysDialogScheduler, ERR_INVALID_VALUE);
127 
128     auto result = CheckImplicitCallPermission(request);
129     if (ERR_OK != result) {
130         return result;
131     }
132     std::vector<DialogAppInfo> dialogAppInfos;
133     request.want.RemoveParam(APP_CLONE_INDEX);
134     bool findDefaultApp = false;
135     int32_t ret = ERR_OK;
136     if (isAppCloneSelector) {
137         ret = GenerateAbilityRequestByAppIndexes(userId, request, dialogAppInfos);
138     } else {
139         ret = GenerateAbilityRequestByAction(userId, request, dialogAppInfos, false, findDefaultApp,
140             isAppCloneSelector);
141     }
142     if (ret != ERR_OK) {
143         TAG_LOGE(AAFwkTag::ABILITYMGR, "generate request failed");
144         return ret;
145     }
146     AbilityUtil::WantSetParameterWindowMode(request.want, windowMode);
147 
148     auto identity = IPCSkeleton::ResetCallingIdentity();
149     auto startAbilityTask = [imp = shared_from_this(), request, userId, identity]
150         (const std::string& bundle, const std::string& abilityName) mutable {
151         TAG_LOGI(AAFwkTag::ABILITYMGR, "callback");
152 
153         // reset calling indentity
154         IPCSkeleton::SetCallingIdentity(identity);
155 
156         AAFwk::Want targetWant = request.want;
157         targetWant.SetElementName(bundle, abilityName);
158         auto callBack = [imp, targetWant, request, userId]() -> int32_t {
159             return imp->ImplicitStartAbilityInner(targetWant, request, userId);
160         };
161         return imp->CallStartAbilityInner(userId, targetWant, callBack, request.callType);
162     };
163 
164     AAFwk::Want want;
165     auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
166     int32_t tokenId = request.want.GetIntParam(Want::PARAM_RESV_CALLER_TOKEN,
167         static_cast<int32_t>(IPCSkeleton::GetCallingTokenID()));
168     AddIdentity(tokenId, identity);
169     if (dialogAppInfos.size() == 0 && AppUtils::GetInstance().IsSelectorDialogDefaultPossion()) {
170         if ((request.want.GetFlags() & Want::FLAG_START_WITHOUT_TIPS) == Want::FLAG_START_WITHOUT_TIPS) {
171             TAG_LOGI(AAFwkTag::ABILITYMGR, "hint dialog generate fail");
172             return ERR_IMPLICIT_START_ABILITY_FAIL;
173         }
174         ret = sysDialogScheduler->GetSelectorDialogWant(dialogAppInfos, request.want, want, request.callerToken);
175         if (ret != ERR_OK) {
176             TAG_LOGE(AAFwkTag::ABILITYMGR, "GetSelectorDialogWant failed");
177             return ret;
178         }
179         if (want.GetBoolParam("isCreateAppGallerySelector", false)) {
180             want.RemoveParam("isCreateAppGallerySelector");
181             DialogSessionManager::GetInstance().CreateImplicitSelectorModalDialog(request, want, userId,
182                 dialogAppInfos);
183             return ERR_IMPLICIT_START_ABILITY_FAIL;
184         }
185         TAG_LOGE(AAFwkTag::ABILITYMGR, "failed, show tips dialog");
186         Want dialogWant = sysDialogScheduler->GetTipsDialogWant(request.callerToken);
187         abilityMgr->StartAbility(dialogWant);
188         return ERR_IMPLICIT_START_ABILITY_FAIL;
189     } else if (dialogAppInfos.size() == 0 && !AppUtils::GetInstance().IsSelectorDialogDefaultPossion()) {
190         std::string type = MatchTypeAndUri(request.want);
191         ret = sysDialogScheduler->GetPcSelectorDialogWant(dialogAppInfos, request.want, want, type,
192             userId, request.callerToken);
193         if (ret != ERR_OK) {
194             TAG_LOGE(AAFwkTag::ABILITYMGR, "GetPcSelectorDialogWant failed");
195             return ret;
196         }
197         if (want.GetBoolParam("isCreateAppGallerySelector", false)) {
198             want.RemoveParam("isCreateAppGallerySelector");
199             DialogSessionManager::GetInstance().CreateImplicitSelectorModalDialog(request, want, userId,
200                 dialogAppInfos);
201             return ERR_IMPLICIT_START_ABILITY_FAIL;
202         }
203         std::vector<DialogAppInfo> dialogAllAppInfos;
204         bool isMoreHapList = true;
205         ret = GenerateAbilityRequestByAction(userId, request, dialogAllAppInfos, isMoreHapList, findDefaultApp,
206             isAppCloneSelector);
207         if (ret != ERR_OK) {
208             TAG_LOGE(AAFwkTag::ABILITYMGR, "request failed");
209             return ret;
210         }
211         if (dialogAllAppInfos.size() == 0) {
212             if ((request.want.GetFlags() & Want::FLAG_START_WITHOUT_TIPS) == Want::FLAG_START_WITHOUT_TIPS) {
213                 TAG_LOGI(AAFwkTag::ABILITYMGR, "null hint dialog");
214                 return ERR_IMPLICIT_START_ABILITY_FAIL;
215             }
216             Want dialogWant = sysDialogScheduler->GetTipsDialogWant(request.callerToken);
217             abilityMgr->StartAbility(dialogWant);
218             return ERR_IMPLICIT_START_ABILITY_FAIL;
219         }
220         ret = sysDialogScheduler->GetPcSelectorDialogWant(dialogAllAppInfos, request.want, want,
221             TYPE_ONLY_MATCH_WILDCARD, userId, request.callerToken);
222         if (ret != ERR_OK) {
223             TAG_LOGE(AAFwkTag::ABILITYMGR, "GetPcSelectorDialogWant failed");
224             return ret;
225         }
226         ret = abilityMgr->StartAbility(request.want, request.callerToken);
227         // reset calling indentity
228         IPCSkeleton::SetCallingIdentity(identity);
229         return ret;
230     }
231 
232     //There is a default opening method add Only one application supports
233     bool defaultPicker = false;
234     defaultPicker = request.want.GetBoolParam(SHOW_DEFAULT_PICKER_FLAG, defaultPicker);
235     if (dialogAppInfos.size() == 1 && !defaultPicker) {
236         auto info = dialogAppInfos.front();
237         // Compatible with the action's sunset scene
238         if (!IsActionImplicitStart(request.want, findDefaultApp)) {
239             TAG_LOGI(AAFwkTag::ABILITYMGR, "ImplicitQueryInfos success,target ability: %{public}s",
240                 info.abilityName.data());
241             return IN_PROCESS_CALL(startAbilityTask(info.bundleName, info.abilityName));
242         }
243     }
244 
245     if (AppUtils::GetInstance().IsSelectorDialogDefaultPossion()) {
246         TAG_LOGI(AAFwkTag::ABILITYMGR, "ImplicitQueryInfos success, multiple apps available");
247         ret = sysDialogScheduler->GetSelectorDialogWant(dialogAppInfos, request.want, want, request.callerToken);
248         if (ret != ERR_OK) {
249             TAG_LOGE(AAFwkTag::ABILITYMGR, "GetSelectorDialogWant failed");
250             return ret;
251         }
252         if (want.GetBoolParam("isCreateAppGallerySelector", false)) {
253             want.RemoveParam("isCreateAppGallerySelector");
254             if (isAppCloneSelector) {
255                 return DialogSessionManager::GetInstance().CreateCloneSelectorModalDialog(request, want,
256                     userId, dialogAppInfos, replaceWantString);
257             }
258             return DialogSessionManager::GetInstance().CreateImplicitSelectorModalDialog(request,
259                 want, userId, dialogAppInfos);
260         }
261         ret = abilityMgr->ImplicitStartAbilityAsCaller(request.want, request.callerToken, nullptr);
262         // reset calling indentity
263         IPCSkeleton::SetCallingIdentity(identity);
264         return ret;
265     }
266 
267     TAG_LOGI(AAFwkTag::ABILITYMGR, "ImplicitQueryInfos success, multiple apps available in pc");
268     std::string type = MatchTypeAndUri(request.want);
269 
270     ret = sysDialogScheduler->GetPcSelectorDialogWant(dialogAppInfos, request.want, want,
271         type, userId, request.callerToken);
272     if (ret != ERR_OK) {
273         TAG_LOGE(AAFwkTag::ABILITYMGR, "GetPcSelectorDialogWant failed");
274         return ret;
275     }
276     if (want.GetBoolParam("isCreateAppGallerySelector", false)) {
277         want.RemoveParam("isCreateAppGallerySelector");
278         if (isAppCloneSelector) {
279             return DialogSessionManager::GetInstance().CreateCloneSelectorModalDialog(request, want, userId,
280                 dialogAppInfos, replaceWantString);
281         }
282         return DialogSessionManager::GetInstance().CreateImplicitSelectorModalDialog(request, want, userId,
283             dialogAppInfos);
284     }
285     ret = abilityMgr->ImplicitStartAbilityAsCaller(request.want, request.callerToken, nullptr);
286     // reset calling indentity
287     IPCSkeleton::SetCallingIdentity(identity);
288     return ret;
289 }
290 
MatchTypeAndUri(const AAFwk::Want &want)291 std::string ImplicitStartProcessor::MatchTypeAndUri(const AAFwk::Want &want)
292 {
293     std::string type = want.GetType();
294     if (type.empty()) {
295         auto uri = want.GetUriString();
296         auto suffixIndex = uri.rfind('.');
297         if (suffixIndex == std::string::npos) {
298             TAG_LOGE(AAFwkTag::ABILITYMGR, "failed, uri: %{public}s", uri.c_str());
299             return "";
300         }
301         type = uri.substr(suffixIndex);
302 #ifdef WITH_DLP
303         if (type == ".dlp") {
304             auto suffixDlpIndex = uri.rfind('.', suffixIndex - 1);
305             if (suffixDlpIndex == std::string::npos) {
306                 TAG_LOGE(AAFwkTag::ABILITYMGR, "failed, uri: %{public}s", uri.c_str());
307                 return "";
308             }
309             type = uri.substr(suffixDlpIndex, suffixIndex - suffixDlpIndex);
310         }
311 #endif // WITH_DLP
312     }
313     return type;
314 }
315 
ProcessLinkType(std::vector<AppExecFwk::AbilityInfo> &abilityInfos)316 static void ProcessLinkType(std::vector<AppExecFwk::AbilityInfo> &abilityInfos)
317 {
318     bool appLinkingExist = false;
319     bool defaultAppExist = false;
320     if (!abilityInfos.size()) {
321         return;
322     }
323     for (const auto &info : abilityInfos) {
324         if (info.linkType == AppExecFwk::LinkType::APP_LINK) {
325             appLinkingExist = true;
326         }
327         if (info.linkType == AppExecFwk::LinkType::DEFAULT_APP) {
328             defaultAppExist = true;
329         }
330     }
331     if (!appLinkingExist && !defaultAppExist) {
332         return;
333     }
334     TAG_LOGI(AAFwkTag::ABILITYMGR, "open applink first");
335     for (auto it = abilityInfos.begin(); it != abilityInfos.end();) {
336         if (it->linkType == AppExecFwk::LinkType::APP_LINK) {
337             it++;
338             continue;
339         }
340         if (it->linkType == AppExecFwk::LinkType::DEFAULT_APP && appLinkingExist) {
341             TAG_LOGD(AAFwkTag::ABILITYMGR, "%{public}s default deleted.", it->name.c_str());
342             it = abilityInfos.erase(it);
343             continue;
344         }
345         if (it->linkType == AppExecFwk::LinkType::DEEP_LINK) {
346             TAG_LOGD(AAFwkTag::ABILITYMGR, "%{public}s deleted.", it->name.c_str());
347             it = abilityInfos.erase(it);
348             continue;
349         }
350         it++;
351     }
352 }
353 
OnlyKeepReserveApp(std::vector<AppExecFwk::AbilityInfo> &abilityInfos, std::vector<AppExecFwk::ExtensionAbilityInfo> &extensionInfos, const AbilityRequest &request)354 void ImplicitStartProcessor::OnlyKeepReserveApp(std::vector<AppExecFwk::AbilityInfo> &abilityInfos,
355     std::vector<AppExecFwk::ExtensionAbilityInfo> &extensionInfos, const AbilityRequest &request)
356 {
357     if (!request.uriReservedFlag) {
358         return;
359     }
360     if (extensionInfos.size() > 0) {
361         extensionInfos.clear();
362     }
363 
364     for (auto it = abilityInfos.begin(); it != abilityInfos.end();) {
365         if (it->bundleName == request.reservedBundleName) {
366             it++;
367             continue;
368         } else {
369             TAG_LOGI(AAFwkTag::ABILITYMGR, "reserve App %{public}s dismatch with bundleName %{public}s",
370                 request.reservedBundleName.c_str(), it->bundleName.c_str());
371             it = abilityInfos.erase(it);
372         }
373     }
374 }
375 
GenerateAbilityRequestByAction(int32_t userId, AbilityRequest &request, std::vector<DialogAppInfo> &dialogAppInfos, bool isMoreHapList, bool &findDefaultApp, bool &isAppCloneSelector)376 int ImplicitStartProcessor::GenerateAbilityRequestByAction(int32_t userId,
377     AbilityRequest &request, std::vector<DialogAppInfo> &dialogAppInfos, bool isMoreHapList, bool &findDefaultApp,
378     bool &isAppCloneSelector)
379 {
380     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
381     TAG_LOGD(AAFwkTag::ABILITYMGR, "%{public}s.", __func__);
382     // get abilityinfos from bms
383     auto bundleMgrHelper = GetBundleManagerHelper();
384     CHECK_POINTER_AND_RETURN(bundleMgrHelper, GET_ABILITY_SERVICE_FAILED);
385     auto abilityInfoFlag = AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_DEFAULT
386         | AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_SKILL_URI
387         | AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION;
388     std::vector<AppExecFwk::AbilityInfo> abilityInfos;
389     std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
390     bool withDefault = false;
391     withDefault = request.want.GetBoolParam(SHOW_DEFAULT_PICKER_FLAG, withDefault) ? false : true;
392     bool appLinkingOnly = false;
393     bool isOpenLink = false;
394     isOpenLink = request.want.HasParameter(OPEN_LINK_APP_LINKING_ONLY);
395     appLinkingOnly = request.want.GetBoolParam(OPEN_LINK_APP_LINKING_ONLY, false);
396 
397     if (IPCSkeleton::GetCallingUid() == NFC_CALLER_UID &&
398         !request.want.GetStringArrayParam(PARAM_ABILITY_APPINFOS).empty()) {
399         TAG_LOGI(AAFwkTag::ABILITYMGR, "caller source: NFC");
400         QueryBmsAppInfos(request, userId, dialogAppInfos);
401     }
402 
403     if (!StartAbilityUtils::IsCallFromAncoShellOrBroker(request.callerToken)) {
404         request.want.RemoveParam(ANCO_PENDING_REQUEST);
405     }
406 
407     if (appLinkingOnly) {
408         abilityInfoFlag = static_cast<uint32_t>(abilityInfoFlag) |
409             static_cast<uint32_t>(AppExecFwk::GetAbilityInfoFlag::GET_ABILITY_INFO_WITH_APP_LINKING);
410     }
411 
412     if (request.uriReservedFlag) {
413         abilityInfoFlag = static_cast<uint32_t>(abilityInfoFlag) |
414             static_cast<uint32_t>(AppExecFwk::GetAbilityInfoFlag::GET_ABILITY_INFO_ONLY_SYSTEM_APP);
415     }
416 
417     if (isOpenLink) {
418         std::string linkUriScheme = request.want.GetUri().GetScheme();
419         if (linkUriScheme == HTTPS_SCHEME_NAME || linkUriScheme == HTTP_SCHEME_NAME) {
420             request.want.SetAction(ACTION_VIEW);
421         }
422     }
423 
424     IN_PROCESS_CALL_WITHOUT_RET(bundleMgrHelper->ImplicitQueryInfos(
425         request.want, abilityInfoFlag, userId, withDefault, abilityInfos, extensionInfos, findDefaultApp));
426 
427     OnlyKeepReserveApp(abilityInfos, extensionInfos, request);
428     if (isOpenLink && extensionInfos.size() > 0) {
429         TAG_LOGI(AAFwkTag::ABILITYMGR, "clear extensionInfos");
430         extensionInfos.clear();
431     }
432     TAG_LOGI(AAFwkTag::ABILITYMGR,
433         "ImplicitQueryInfos, abilityInfo size : %{public}zu, extensionInfos size: %{public}zu", abilityInfos.size(),
434         extensionInfos.size());
435 
436     if (appLinkingOnly && abilityInfos.size() == 0) {
437         TAG_LOGE(AAFwkTag::ABILITYMGR, "not match app");
438         return ERR_IMPLICIT_START_ABILITY_FAIL;
439     }
440 
441     if (!appLinkingOnly) {
442         ProcessLinkType(abilityInfos);
443     }
444 
445 #ifdef WITH_DLP
446     if (request.want.GetBoolParam(AbilityUtil::DLP_PARAMS_SANDBOX, false)) {
447         Security::DlpPermission::DlpFileKits::ConvertAbilityInfoWithSupportDlp(request.want, abilityInfos);
448         extensionInfos.clear();
449     }
450 #endif // WITH_DLP
451 
452     if (abilityInfos.size() + extensionInfos.size() > 1) {
453         TAG_LOGI(AAFwkTag::ABILITYMGR, "filter applications by erms");
454         bool ret = FilterAbilityList(request.want, abilityInfos, extensionInfos, userId);
455         FindAppClone(abilityInfos, extensionInfos, isAppCloneSelector);
456         if (!ret) {
457             TAG_LOGE(AAFwkTag::ABILITYMGR, "FilterAbilityList failed");
458         }
459     }
460 
461     auto isExtension = request.callType == AbilityCallType::START_EXTENSION_TYPE;
462 
463     Want implicitwant;
464     std::string typeName = MatchTypeAndUri(request.want);
465 
466     implicitwant.SetAction(request.want.GetAction());
467     implicitwant.SetType(TYPE_ONLY_MATCH_WILDCARD);
468     std::vector<AppExecFwk::AbilityInfo> implicitAbilityInfos;
469     std::vector<AppExecFwk::ExtensionAbilityInfo> implicitExtensionInfos;
470     std::vector<std::string> infoNames;
471     if (!AppUtils::GetInstance().IsSelectorDialogDefaultPossion() && isMoreHapList) {
472         IN_PROCESS_CALL_WITHOUT_RET(bundleMgrHelper->ImplicitQueryInfos(implicitwant, abilityInfoFlag, userId,
473             withDefault, implicitAbilityInfos, implicitExtensionInfos, findDefaultApp));
474         if (implicitAbilityInfos.size() != 0 && typeName != TYPE_ONLY_MATCH_WILDCARD) {
475             for (auto implicitAbilityInfo : implicitAbilityInfos) {
476                 infoNames.emplace_back(implicitAbilityInfo.bundleName + "#" +
477                     implicitAbilityInfo.moduleName + "#" + implicitAbilityInfo.name);
478             }
479         }
480     }
481 
482     if (abilityInfos.size() == 1) {
483         auto skillUri =  abilityInfos.front().skillUri;
484         SetTargetLinkInfo(skillUri, request.want);
485         if (abilityInfos.front().linkType == AppExecFwk::LinkType::APP_LINK) {
486             EventInfo eventInfo;
487             eventInfo.bundleName = abilityInfos.front().bundleName;
488             eventInfo.callerBundleName = request.want.GetStringParam(Want::PARAM_RESV_CALLER_BUNDLE_NAME);
489             eventInfo.uri = request.want.GetUriString();
490             SendAbilityEvent(EventName::START_ABILITY_BY_APP_LINKING, HiSysEventType::BEHAVIOR, eventInfo);
491         }
492     }
493 
494     {
495         HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "for (const auto &info : abilityInfos)");
496         bool isExistDefaultApp = IsExistDefaultApp(userId, typeName);
497         for (const auto &info : abilityInfos) {
498             AddInfoParam param = {
499                 .info = info,
500                 .userId = userId,
501                 .isExtension = isExtension,
502                 .isMoreHapList = isMoreHapList,
503                 .withDefault = withDefault,
504                 .typeName = typeName,
505                 .infoNames = infoNames,
506                 .isExistDefaultApp = isExistDefaultApp
507             };
508             AddAbilityInfoToDialogInfos(param, dialogAppInfos);
509         }
510     }
511 
512     for (const auto &info : extensionInfos) {
513         if (!isExtension || !CheckImplicitStartExtensionIsValid(request, info)) {
514             continue;
515         }
516         DialogAppInfo dialogAppInfo;
517         dialogAppInfo.abilityName = info.name;
518         dialogAppInfo.bundleName = info.bundleName;
519         dialogAppInfo.abilityIconId = info.iconId;
520         dialogAppInfo.abilityLabelId = info.labelId;
521         dialogAppInfo.bundleIconId = info.applicationInfo.iconId;
522         dialogAppInfo.bundleLabelId = info.applicationInfo.labelId;
523         dialogAppInfo.visible = info.visible;
524         dialogAppInfo.appIndex = info.applicationInfo.appIndex;
525         dialogAppInfo.multiAppMode = info.applicationInfo.multiAppMode;
526         dialogAppInfos.emplace_back(dialogAppInfo);
527     }
528 
529     return ERR_OK;
530 }
531 
GenerateAbilityRequestByAppIndexes(int32_t userId, AbilityRequest &request, std::vector<DialogAppInfo> &dialogAppInfos)532 int ImplicitStartProcessor::GenerateAbilityRequestByAppIndexes(int32_t userId, AbilityRequest &request,
533     std::vector<DialogAppInfo> &dialogAppInfos)
534 {
535     auto appIndexes = StartAbilityUtils::GetCloneAppIndexes(request.want.GetBundle(), userId);
536     if (appIndexes.size() > AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
537         TAG_LOGE(AAFwkTag::ABILITYMGR, "too large appIndexes");
538         return ERR_INVALID_VALUE;
539     }
540     auto bms = GetBundleManagerHelper();
541     CHECK_POINTER_AND_RETURN(bms, GET_ABILITY_SERVICE_FAILED);
542     auto abilityInfoFlag = static_cast<uint32_t>(AbilityRuntime::StartupUtil::BuildAbilityInfoFlag()) |
543         static_cast<uint32_t>(AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_SKILL);
544     std::vector<AppExecFwk::AbilityInfo> abilityInfos;
545     abilityInfos.emplace_back(request.abilityInfo);
546     for (auto &appIndex: appIndexes) {
547         AppExecFwk::AbilityInfo abilityInfo;
548         IN_PROCESS_CALL_WITHOUT_RET(bms->QueryCloneAbilityInfo(request.want.GetElement(), abilityInfoFlag, appIndex,
549             abilityInfo, userId));
550         if (abilityInfo.name.empty() || abilityInfo.bundleName.empty()) {
551             int32_t ret = FindExtensionInfo(request.want, abilityInfoFlag, userId, appIndex, abilityInfo);
552             if (ret != ERR_OK) {
553                 TAG_LOGE(AAFwkTag::ABILITYMGR, "query info failed");
554                 return ret;
555             }
556         }
557         abilityInfos.emplace_back(abilityInfo);
558     }
559     for (const auto &info : abilityInfos) {
560         DialogAppInfo dialogAppInfo;
561         dialogAppInfo.abilityName = info.name;
562         dialogAppInfo.bundleName = info.bundleName;
563         dialogAppInfo.moduleName = info.moduleName;
564         dialogAppInfo.abilityIconId = info.iconId;
565         dialogAppInfo.abilityLabelId = info.labelId;
566         dialogAppInfo.bundleIconId = info.applicationInfo.iconId;
567         dialogAppInfo.bundleLabelId = info.applicationInfo.labelId;
568         dialogAppInfo.visible = info.visible;
569         dialogAppInfo.appIndex = info.applicationInfo.appIndex;
570         dialogAppInfo.multiAppMode = info.applicationInfo.multiAppMode;
571         dialogAppInfos.emplace_back(dialogAppInfo);
572     }
573     return ERR_OK;
574 }
575 
FindExtensionInfo(const Want &want, int32_t flags, int32_t userId, int32_t appIndex, AppExecFwk::AbilityInfo &abilityInfo)576 int ImplicitStartProcessor::FindExtensionInfo(const Want &want, int32_t flags, int32_t userId,
577     int32_t appIndex, AppExecFwk::AbilityInfo &abilityInfo)
578 {
579     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
580     auto bms = GetBundleManagerHelper();
581     CHECK_POINTER_AND_RETURN(bms, GET_ABILITY_SERVICE_FAILED);
582     AppExecFwk::ExtensionAbilityInfo extensionInfo;
583     IN_PROCESS_CALL_WITHOUT_RET(bms->QueryCloneExtensionAbilityInfoWithAppIndex(want.GetElement(),
584         flags, appIndex, extensionInfo, userId));
585     if (extensionInfo.bundleName.empty() || extensionInfo.name.empty()) {
586         TAG_LOGE(AAFwkTag::ABILITYMGR, "extensionInfo empty.");
587         return RESOLVE_ABILITY_ERR;
588     }
589     if (AbilityRuntime::StartupUtil::IsSupportAppClone(extensionInfo.type)) {
590         AbilityRuntime::StartupUtil::InitAbilityInfoFromExtension(extensionInfo, abilityInfo);
591         return ERR_OK;
592     }
593     return ERR_APP_CLONE_INDEX_INVALID;
594 }
595 
QueryBmsAppInfos(AbilityRequest &request, int32_t userId, std::vector<DialogAppInfo> &dialogAppInfos)596 int ImplicitStartProcessor::QueryBmsAppInfos(AbilityRequest &request, int32_t userId,
597     std::vector<DialogAppInfo> &dialogAppInfos)
598 {
599     auto bundleMgrHelper = GetBundleManagerHelper();
600     std::vector<AppExecFwk::AbilityInfo> bmsApps;
601     auto abilityInfoFlag = AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_DEFAULT
602         | AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_SKILL_URI
603         | AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION;
604     std::vector<std::string> apps = request.want.GetStringArrayParam(PARAM_ABILITY_APPINFOS);
605     for (std::string appInfoStr : apps) {
606         AppExecFwk::AbilityInfo abilityInfo;
607         std::vector<std::string> appInfos = ImplicitStartProcessor::SplitStr(appInfoStr, '/');
608         if (appInfos.empty() || appInfos.size() != NFC_QUERY_LENGTH) {
609             continue;
610         }
611         std::string bundleName = appInfos[0];
612         std::string abilityName = appInfos[1];
613         std::string queryAbilityName = bundleName.append(abilityName);
614         Want want;
615         want.SetElementName(appInfos[0], queryAbilityName);
616 
617         IN_PROCESS_CALL_WITHOUT_RET(bundleMgrHelper->QueryAbilityInfo(want, abilityInfoFlag,
618             userId, abilityInfo));
619         if (!abilityInfo.name.empty() && !abilityInfo.bundleName.empty() && !abilityInfo.moduleName.empty()) {
620             bmsApps.emplace_back(abilityInfo);
621         }
622     }
623     if (!bmsApps.empty()) {
624         for (const auto &abilityInfo : bmsApps) {
625             DialogAppInfo dialogAppInfo;
626             dialogAppInfo.abilityName = abilityInfo.name;
627             dialogAppInfo.bundleName = abilityInfo.bundleName;
628             dialogAppInfo.moduleName = abilityInfo.moduleName;
629             dialogAppInfo.abilityIconId = abilityInfo.iconId;
630             dialogAppInfo.abilityLabelId = abilityInfo.labelId;
631             dialogAppInfo.bundleIconId = abilityInfo.applicationInfo.iconId;
632             dialogAppInfo.bundleLabelId = abilityInfo.applicationInfo.labelId;
633             dialogAppInfo.visible = abilityInfo.visible;
634             dialogAppInfo.appIndex = abilityInfo.applicationInfo.appIndex;
635             dialogAppInfo.multiAppMode = abilityInfo.applicationInfo.multiAppMode;
636             dialogAppInfos.emplace_back(dialogAppInfo);
637         }
638     }
639     return ERR_OK;
640 }
641 
SplitStr(const std::string& str, char delimiter)642 std::vector<std::string> ImplicitStartProcessor::SplitStr(const std::string& str, char delimiter)
643 {
644     std::stringstream ss(str);
645     std::vector<std::string> result;
646     std::string s;
647     while (std::getline(ss, s, delimiter)) {
648         result.push_back(s);
649     }
650     return result;
651 }
652 
CheckImplicitStartExtensionIsValid(const AbilityRequest &request, const AppExecFwk::ExtensionAbilityInfo &extensionInfo)653 bool ImplicitStartProcessor::CheckImplicitStartExtensionIsValid(const AbilityRequest &request,
654     const AppExecFwk::ExtensionAbilityInfo &extensionInfo)
655 {
656     if (!request.want.GetElement().GetBundleName().empty()) {
657         return true;
658     }
659     TAG_LOGD(
660         AAFwkTag::ABILITYMGR, "ImplicitStartExtension type: %{public}d.", static_cast<int32_t>(extensionInfo.type));
661     if (!IsExtensionInWhiteList(extensionInfo.type)) {
662         TAG_LOGE(AAFwkTag::ABILITYMGR, "ImplicitStart not allowed");
663         return false;
664     }
665     return true;
666 }
667 
ImplicitStartAbilityInner(const Want &targetWant, const AbilityRequest &request, int32_t userId)668 int32_t ImplicitStartProcessor::ImplicitStartAbilityInner(const Want &targetWant,
669     const AbilityRequest &request, int32_t userId)
670 {
671     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
672     auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
673     CHECK_POINTER_AND_RETURN(abilityMgr, ERR_INVALID_VALUE);
674 
675     int32_t result = ERR_OK;
676     switch (request.callType) {
677         case AbilityCallType::START_OPTIONS_TYPE: {
678             StartOptions startOptions;
679             auto displayId = targetWant.GetIntParam(Want::PARAM_RESV_DISPLAY_ID, 0);
680             auto windowMode = targetWant.GetIntParam(Want::PARAM_RESV_WINDOW_MODE, 0);
681             startOptions.SetDisplayID(static_cast<int32_t>(displayId));
682             startOptions.SetWindowMode(static_cast<int32_t>(windowMode));
683             result = abilityMgr->ImplicitStartAbility(
684                 targetWant, startOptions, request.callerToken, userId, request.requestCode);
685             break;
686         }
687         case AbilityCallType::START_SETTINGS_TYPE: {
688             CHECK_POINTER_AND_RETURN(request.startSetting, ERR_INVALID_VALUE);
689             result = abilityMgr->ImplicitStartAbility(
690                 targetWant, *request.startSetting, request.callerToken, userId, request.requestCode);
691             break;
692         }
693         case AbilityCallType::START_EXTENSION_TYPE:
694             result = abilityMgr->ImplicitStartExtensionAbility(
695                 targetWant, request.callerToken, userId, request.extensionType);
696             break;
697         default:
698             result = abilityMgr->StartAbilityWrap(
699                 targetWant, request.callerToken, request.requestCode, false, userId, false, 0, false, true);
700             break;
701     }
702 
703     return result;
704 }
705 
CallStartAbilityInner(int32_t userId, const Want &want, const StartAbilityClosure &callBack, const AbilityCallType &callType)706 int ImplicitStartProcessor::CallStartAbilityInner(int32_t userId,
707     const Want &want, const StartAbilityClosure &callBack, const AbilityCallType &callType)
708 {
709     EventInfo eventInfo;
710     eventInfo.userId = userId;
711     eventInfo.bundleName = want.GetElement().GetBundleName();
712     eventInfo.moduleName = want.GetElement().GetModuleName();
713     eventInfo.abilityName = want.GetElement().GetAbilityName();
714 
715     if (callType == AbilityCallType::INVALID_TYPE) {
716         SendAbilityEvent(EventName::START_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
717     }
718 
719     TAG_LOGI(AAFwkTag::ABILITYMGR, "ability:%{public}s, bundle:%{public}s", eventInfo.abilityName.c_str(),
720         eventInfo.bundleName.c_str());
721 
722     auto ret = callBack();
723     if (ret != ERR_OK) {
724         eventInfo.errCode = ret;
725         if (callType == AbilityCallType::INVALID_TYPE) {
726             SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
727         }
728     }
729     return ret;
730 }
731 
GetBundleManagerHelper()732 std::shared_ptr<AppExecFwk::BundleMgrHelper> ImplicitStartProcessor::GetBundleManagerHelper()
733 {
734     if (iBundleManagerHelper_ == nullptr) {
735         iBundleManagerHelper_ = AbilityUtil::GetBundleManagerHelper();
736     }
737     return iBundleManagerHelper_;
738 }
739 
GetDefaultAppProxy()740 sptr<AppExecFwk::IDefaultApp> ImplicitStartProcessor::GetDefaultAppProxy()
741 {
742     auto bundleMgrHelper = GetBundleManagerHelper();
743     if (bundleMgrHelper == nullptr) {
744         TAG_LOGE(AAFwkTag::ABILITYMGR, "null bundleMgrHelper");
745         return nullptr;
746     }
747     auto defaultAppProxy = bundleMgrHelper->GetDefaultAppProxy();
748     if (defaultAppProxy == nullptr) {
749         TAG_LOGE(AAFwkTag::ABILITYMGR, "null defaultAppProxy");
750         return nullptr;
751     }
752     return defaultAppProxy;
753 }
754 
FilterAbilityList(const Want &want, std::vector<AppExecFwk::AbilityInfo> &abilityInfos, std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos, int32_t userId)755 bool ImplicitStartProcessor::FilterAbilityList(const Want &want, std::vector<AppExecFwk::AbilityInfo> &abilityInfos,
756     std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos, int32_t userId)
757 {
758     ErmsCallerInfo callerInfo;
759     GetEcologicalCallerInfo(want, callerInfo, userId);
760     int ret = IN_PROCESS_CALL(AbilityEcologicalRuleMgrServiceClient::GetInstance()->
761         EvaluateResolveInfos(want, callerInfo, 0, abilityInfos, extensionInfos));
762     if (ret != ERR_OK) {
763         TAG_LOGE(AAFwkTag::ABILITYMGR, "resolve infos failed");
764         return false;
765     }
766     return true;
767 }
768 
GetEcologicalCallerInfo(const Want &want, ErmsCallerInfo &callerInfo, int32_t userId)769 void ImplicitStartProcessor::GetEcologicalCallerInfo(const Want &want, ErmsCallerInfo &callerInfo, int32_t userId)
770 {
771     callerInfo.packageName = want.GetStringParam(Want::PARAM_RESV_CALLER_BUNDLE_NAME);
772     callerInfo.uid = want.GetIntParam(Want::PARAM_RESV_CALLER_UID, IPCSkeleton::GetCallingUid());
773     callerInfo.pid = want.GetIntParam(Want::PARAM_RESV_CALLER_PID, IPCSkeleton::GetCallingPid());
774     callerInfo.targetAppType = ErmsCallerInfo::TYPE_INVALID;
775     callerInfo.callerAppType = ErmsCallerInfo::TYPE_INVALID;
776 
777     auto bundleMgrHelper = GetBundleManagerHelper();
778     if (bundleMgrHelper == nullptr) {
779         TAG_LOGE(AAFwkTag::ABILITYMGR, "bundleMgrHelper empty");
780         return;
781     }
782 
783     std::string targetBundleName = want.GetBundle();
784     AppExecFwk::ApplicationInfo targetAppInfo;
785     bool getTargetResult = IN_PROCESS_CALL(bundleMgrHelper->GetApplicationInfo(targetBundleName,
786         AppExecFwk::ApplicationFlag::GET_BASIC_APPLICATION_INFO, userId, targetAppInfo));
787     if (!getTargetResult) {
788         TAG_LOGE(AAFwkTag::ABILITYMGR, "get targetAppInfo failed");
789     } else if (targetAppInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE) {
790         TAG_LOGD(AAFwkTag::ABILITYMGR, "the target type  is atomic service");
791         callerInfo.targetAppType = ErmsCallerInfo::TYPE_ATOM_SERVICE;
792     } else if (targetAppInfo.bundleType == AppExecFwk::BundleType::APP) {
793         TAG_LOGD(AAFwkTag::ABILITYMGR, "the target type is app");
794         callerInfo.targetAppType = ErmsCallerInfo::TYPE_HARMONY_APP;
795     } else {
796         TAG_LOGD(AAFwkTag::ABILITYMGR, "the target type is invalid type");
797     }
798 
799     std::string callerBundleName;
800     ErrCode err = IN_PROCESS_CALL(bundleMgrHelper->GetNameForUid(callerInfo.uid, callerBundleName));
801     if (err != ERR_OK) {
802         TAG_LOGE(AAFwkTag::ABILITYMGR, "callerBundleName empty");
803         return;
804     }
805     AppExecFwk::ApplicationInfo callerAppInfo;
806     bool getCallerResult = IN_PROCESS_CALL(bundleMgrHelper->GetApplicationInfo(callerBundleName,
807         AppExecFwk::ApplicationFlag::GET_BASIC_APPLICATION_INFO, userId, callerAppInfo));
808     if (!getCallerResult) {
809         TAG_LOGD(AAFwkTag::ABILITYMGR, "get callerAppInfo failed");
810     } else if (callerAppInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE) {
811         TAG_LOGD(AAFwkTag::ABILITYMGR, "the caller type  is atomic service");
812         callerInfo.callerAppType = ErmsCallerInfo::TYPE_ATOM_SERVICE;
813     } else if (callerAppInfo.bundleType == AppExecFwk::BundleType::APP) {
814         TAG_LOGD(AAFwkTag::ABILITYMGR, "the caller type is app");
815         callerInfo.callerAppType = ErmsCallerInfo::TYPE_HARMONY_APP;
816     } else {
817         TAG_LOGD(AAFwkTag::ABILITYMGR, "the caller type is invalid type");
818     }
819 }
820 
AddIdentity(int32_t tokenId, std::string identity)821 void ImplicitStartProcessor::AddIdentity(int32_t tokenId, std::string identity)
822 {
823     std::lock_guard guard(identityListLock_);
824     if (identityList_.size() == IDENTITY_LIST_MAX_SIZE) {
825         identityList_.pop_front();
826         identityList_.emplace_back(IdentityNode(tokenId, identity));
827         return;
828     }
829     identityList_.emplace_back(IdentityNode(tokenId, identity));
830 }
831 
ResetCallingIdentityAsCaller(int32_t tokenId, bool flag)832 void ImplicitStartProcessor::ResetCallingIdentityAsCaller(int32_t tokenId, bool flag)
833 {
834     std::lock_guard guard(identityListLock_);
835     for (auto it = identityList_.begin(); it != identityList_.end(); it++) {
836         if (it->tokenId == tokenId) {
837             IPCSkeleton::SetCallingIdentity(it->identity);
838             if (flag) {
839                 identityList_.erase(it);
840             }
841             return;
842         }
843     }
844 }
845 
RemoveIdentity(int32_t tokenId)846 void ImplicitStartProcessor::RemoveIdentity(int32_t tokenId)
847 {
848     std::lock_guard guard(identityListLock_);
849     for (auto it = identityList_.begin(); it != identityList_.end(); it++) {
850         if (it->tokenId == tokenId) {
851             identityList_.erase(it);
852             return;
853         }
854     }
855 }
856 
AddAbilityInfoToDialogInfos(const AddInfoParam &param, std::vector<DialogAppInfo> &dialogAppInfos)857 void ImplicitStartProcessor::AddAbilityInfoToDialogInfos(const AddInfoParam &param,
858     std::vector<DialogAppInfo> &dialogAppInfos)
859 {
860     if (param.isExtension && param.info.type != AbilityType::EXTENSION) {
861         return;
862     }
863     if (!AppUtils::GetInstance().IsSelectorDialogDefaultPossion()) {
864         bool isDefaultFlag = param.withDefault && param.isExistDefaultApp;
865         if (!param.isMoreHapList && !isDefaultFlag &&
866             std::find(param.infoNames.begin(), param.infoNames.end(),
867             (param.info.bundleName + "#" + param.info.moduleName + "#" + param.info.name)) != param.infoNames.end()) {
868             return;
869         }
870     }
871     DialogAppInfo dialogAppInfo;
872     dialogAppInfo.abilityName = param.info.name;
873     dialogAppInfo.bundleName = param.info.bundleName;
874     dialogAppInfo.moduleName = param.info.moduleName;
875     dialogAppInfo.abilityIconId = param.info.iconId;
876     dialogAppInfo.abilityLabelId = param.info.labelId;
877     dialogAppInfo.bundleIconId = param.info.applicationInfo.iconId;
878     dialogAppInfo.bundleLabelId = param.info.applicationInfo.labelId;
879     dialogAppInfo.visible = param.info.visible;
880     dialogAppInfo.appIndex = param.info.applicationInfo.appIndex;
881     dialogAppInfo.multiAppMode = param.info.applicationInfo.multiAppMode;
882     dialogAppInfos.emplace_back(dialogAppInfo);
883 }
884 
IsExistDefaultApp(int32_t userId, const std::string &typeName)885 bool ImplicitStartProcessor::IsExistDefaultApp(int32_t userId, const std::string &typeName)
886 {
887     auto defaultMgr = GetDefaultAppProxy();
888     AppExecFwk::BundleInfo bundleInfo;
889     ErrCode ret =
890         IN_PROCESS_CALL(defaultMgr->GetDefaultApplication(userId, typeName, bundleInfo));
891     if (ret != ERR_OK) {
892         return false;
893     }
894 
895     if (bundleInfo.abilityInfos.size() == 1) {
896         TAG_LOGI(AAFwkTag::ABILITYMGR, "find default ability");
897         return true;
898     } else if (bundleInfo.extensionInfos.size() == 1) {
899         TAG_LOGI(AAFwkTag::ABILITYMGR, "find default extension");
900         return true;
901     } else {
902         TAG_LOGI(AAFwkTag::ABILITYMGR, "getDefaultApplication failed");
903         return false;
904     }
905 }
906 
SetTargetLinkInfo(const std::vector<AppExecFwk::SkillUriForAbilityAndExtension> &skillUri, Want &want)907 void ImplicitStartProcessor::SetTargetLinkInfo(const std::vector<AppExecFwk::SkillUriForAbilityAndExtension> &skillUri,
908     Want &want)
909 {
910     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
911     for (const auto& iter : skillUri) {
912         if (iter.isMatch) {
913             want.RemoveParam("send_to_erms_targetLinkFeature");
914             want.SetParam("send_to_erms_targetLinkFeature", iter.linkFeature);
915             want.RemoveParam("send_to_erms_targetLinkType");
916             if (want.GetBoolParam(OPEN_LINK_APP_LINKING_ONLY, false)) {
917                 want.SetParam("send_to_erms_targetLinkType", AbilityCallerInfo::LINK_TYPE_UNIVERSAL_LINK);
918             } else if ((iter.scheme == "https" || iter.scheme == "http") &&
919                 want.GetAction().compare(ACTION_VIEW) == 0) {
920                 want.SetParam("send_to_erms_targetLinkType", AbilityCallerInfo::LINK_TYPE_WEB_LINK);
921             } else {
922                 want.SetParam("send_to_erms_targetLinkType", AbilityCallerInfo::LINK_TYPE_DEEP_LINK);
923             }
924         }
925     }
926 }
927 
IsActionImplicitStart(const Want &want, bool findDeafultApp)928 bool ImplicitStartProcessor::IsActionImplicitStart(const Want &want, bool findDeafultApp)
929 {
930     std::string supportStart = OHOS::system::GetParameter(SUPPORT_ACTION_START_SELECTOR, "false");
931     if (supportStart == "false") {
932         return false;
933     }
934 
935     if (findDeafultApp) {
936         return false;
937     }
938 
939     std::string bundleName = "";
940     if (DeepLinkReserveConfig::GetInstance().isLinkReserved(want.GetUriString(),
941         bundleName)) {
942         return false;
943     }
944 
945     if (want.GetUriString() == "" ||
946         (want.GetUri().GetScheme() != "file" && want.GetUri().GetScheme() != "content" &&
947         want.GetUri().GetScheme() != "mailto")) {
948         return false;
949     }
950 
951     if (want.GetElement().GetBundleName() != "") {
952         return false;
953     }
954 
955     return true;
956 }
957 
FindAppClone(std::vector<AppExecFwk::AbilityInfo> &abilityInfos, std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos, bool &isAppCloneSelector)958 int32_t ImplicitStartProcessor::FindAppClone(std::vector<AppExecFwk::AbilityInfo> &abilityInfos,
959     std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos, bool &isAppCloneSelector)
960 {
961     if (abilityInfos.size() > 0 && extensionInfos.size() > 0) {
962         return ERR_OK;
963     }
964 
965     bool isExitAbilityAppClone = FindAbilityAppClone(abilityInfos);
966     bool isExitExtensionAppClone = FindExtensionAppClone(extensionInfos);
967     if ((abilityInfos.size() == 0 && FindExtensionAppClone(extensionInfos)) ||
968         (extensionInfos.size() == 0 && FindAbilityAppClone(abilityInfos))) {
969         isAppCloneSelector = true;
970     }
971 
972     return ERR_OK;
973 }
974 
FindAbilityAppClone(std::vector<AppExecFwk::AbilityInfo> &abilityInfos)975 bool ImplicitStartProcessor::FindAbilityAppClone(std::vector<AppExecFwk::AbilityInfo> &abilityInfos)
976 {
977     if (abilityInfos.size() <= 1) {
978         return false;
979     }
980     std::string appCloneBundleName = "";
981     std::string appCloneAbilityName = "";
982     for (const auto &iter : abilityInfos) {
983         if (appCloneBundleName == "" && appCloneAbilityName == "") {
984             appCloneBundleName = iter.bundleName;
985             appCloneAbilityName = iter.name;
986         }
987         if (iter.bundleName != appCloneBundleName || iter.name != appCloneAbilityName) {
988             return false;
989         }
990     }
991     return true;
992 }
993 
FindExtensionAppClone(std::vector<AppExecFwk::ExtensionAbilityInfo> &extensionInfos)994 bool ImplicitStartProcessor::FindExtensionAppClone(std::vector<AppExecFwk::ExtensionAbilityInfo> &extensionInfos)
995 {
996     if (extensionInfos.size() <= 1) {
997         return false;
998     }
999     std::string appCloneBundleName = "";
1000     std::string appCloneAbilityName = "";
1001     for (const auto &iter : extensionInfos) {
1002         if (appCloneBundleName == "" && appCloneAbilityName == "") {
1003             appCloneBundleName = iter.bundleName;
1004             appCloneAbilityName = iter.name;
1005         }
1006         if (iter.bundleName != appCloneBundleName || iter.name != appCloneAbilityName) {
1007             return false;
1008         }
1009     }
1010     return true;
1011 }
1012 }  // namespace AAFwk
1013 }  // namespace OHOS
1014