1/*
2 * Copyright (c) 2021-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 "pending_want_manager.h"
17
18#include "ability_manager_service.h"
19#include "ability_util.h"
20#include "distributed_client.h"
21#include "hitrace_meter.h"
22#include "permission_constants.h"
23#include "session_manager_lite.h"
24#include "utils/app_mgr_util.h"
25#include "wm_common.h"
26
27namespace OHOS {
28namespace AAFwk {
29using namespace OHOS::EventFwk;
30using namespace std::chrono;
31using namespace std::placeholders;
32
33PendingWantManager::PendingWantManager()
34{
35}
36
37PendingWantManager::~PendingWantManager()
38{
39}
40
41sptr<IWantSender> PendingWantManager::GetWantSender(int32_t callingUid, int32_t uid, const bool isSystemApp,
42    const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken, int32_t appIndex)
43{
44    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
45    if (wantSenderInfo.type != static_cast<int32_t>(OperationType::SEND_COMMON_EVENT)) {
46        if (callingUid != uid &&
47            !isSystemApp &&
48            !AAFwk::PermissionVerification::GetInstance()->IsSACall()) {
49            TAG_LOGE(AAFwkTag::WANTAGENT, "cannot send");
50            return nullptr;
51        }
52    }
53
54    if (wantSenderInfo.type == static_cast<int32_t>(OperationType::START_SERVICE_EXTENSION) && !isSystemApp &&
55        !AAFwk::PermissionVerification::GetInstance()->IsSACall()) {
56        TAG_LOGE(AAFwkTag::WANTAGENT, "non-system app called");
57        return nullptr;
58    }
59
60    WantSenderInfo info = wantSenderInfo;
61
62    if (wantSenderInfo.type != static_cast<int32_t>(OperationType::SEND_COMMON_EVENT) &&
63        !isSystemApp && !AAFwk::PermissionVerification::GetInstance()->IsSACall()) {
64        for (auto it = info.allWants.begin(); it != info.allWants.end(); ++it) {
65            if (info.bundleName != it->want.GetBundle()) {
66                info.allWants.erase(it);
67            } else {
68                it->want.RemoveParam("ohos.extra.param.key.appCloneIndex");
69            }
70        }
71    }
72
73    return GetWantSenderLocked(callingUid, uid, wantSenderInfo.userId, info, callerToken, appIndex);
74}
75
76sptr<IWantSender> PendingWantManager::GetWantSenderLocked(const int32_t callingUid, const int32_t uid,
77    const int32_t userId, WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken, int32_t appIndex)
78{
79    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
80
81    bool needCreate = (static_cast<uint32_t>(wantSenderInfo.flags) &
82        static_cast<uint32_t>(Flags::NO_BUILD_FLAG)) == 0;
83    bool needCancel = (static_cast<uint32_t>(wantSenderInfo.flags) &
84        static_cast<uint32_t>(Flags::CANCEL_PRESENT_FLAG)) != 0;
85    bool needUpdate = (static_cast<uint32_t>(wantSenderInfo.flags) &
86        static_cast<uint32_t>(Flags::UPDATE_PRESENT_FLAG)) != 0;
87
88    std::shared_ptr<PendingWantKey> pendingKey = std::make_shared<PendingWantKey>();
89    pendingKey->SetBundleName(wantSenderInfo.bundleName);
90    pendingKey->SetRequestWho(wantSenderInfo.resultWho);
91    pendingKey->SetRequestCode(wantSenderInfo.requestCode);
92    pendingKey->SetFlags(wantSenderInfo.flags);
93    pendingKey->SetUserId(wantSenderInfo.userId);
94    pendingKey->SetType(wantSenderInfo.type);
95    pendingKey->SetAppIndex(appIndex);
96    if (wantSenderInfo.allWants.size() > 0) {
97        pendingKey->SetRequestWant(wantSenderInfo.allWants.back().want);
98        pendingKey->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
99        pendingKey->SetAllWantsInfos(wantSenderInfo.allWants);
100    }
101    std::lock_guard<ffrt::mutex> locker(mutex_);
102    auto ref = GetPendingWantRecordByKey(pendingKey);
103    if (ref != nullptr) {
104        if (!needCancel) {
105            if (needUpdate && wantSenderInfo.allWants.size() > 0) {
106                ref->GetKey()->SetRequestWant(wantSenderInfo.allWants.back().want);
107                ref->GetKey()->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
108                wantSenderInfo.allWants.back().want = ref->GetKey()->GetRequestWant();
109                wantSenderInfo.allWants.back().resolvedTypes = ref->GetKey()->GetRequestResolvedType();
110                ref->GetKey()->SetAllWantsInfos(wantSenderInfo.allWants);
111                ref->SetCallerUid(callingUid);
112            }
113            return ref;
114        }
115        MakeWantSenderCanceledLocked(*ref);
116        wantRecords_.erase(ref->GetKey());
117        EraseBundleRecord(wantSenderInfo.allWants, ref->GetKey());
118    }
119
120    if (!needCreate) {
121        return (ref != nullptr) ? ref : nullptr;
122    }
123
124    sptr<PendingWantRecord> rec =
125        new (std::nothrow) PendingWantRecord(shared_from_this(), uid, IPCSkeleton::GetCallingTokenID(),
126        callerToken, pendingKey);
127    if (rec != nullptr) {
128        rec->SetCallerUid(callingUid);
129        pendingKey->SetCode(PendingRecordIdCreate());
130        wantRecords_.insert(std::make_pair(pendingKey, rec));
131        InsertBundleRecord(wantSenderInfo.allWants, pendingKey);
132        TAG_LOGD(AAFwkTag::WANTAGENT, "wantRecords_ size %{public}zu", wantRecords_.size());
133        return rec;
134    }
135    return nullptr;
136}
137
138void PendingWantManager::MakeWantSenderCanceledLocked(PendingWantRecord &record)
139{
140    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
141
142    record.SetCanceled();
143    for (auto &callback : record.GetCancelCallbacks()) {
144        callback->Send(record.GetKey()->GetRequestCode());
145    }
146}
147
148sptr<PendingWantRecord> PendingWantManager::GetPendingWantRecordByKey(const std::shared_ptr<PendingWantKey> &key)
149{
150    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
151    for (const auto &item : wantRecords_) {
152        const auto pendingKey = item.first;
153        const auto pendingRecord = item.second;
154        if ((pendingRecord != nullptr) && CheckPendingWantRecordByKey(pendingKey, key)) {
155            return pendingRecord;
156        }
157    }
158    return nullptr;
159}
160
161bool PendingWantManager::CheckPendingWantRecordByKey(
162    const std::shared_ptr<PendingWantKey> &inputKey, const std::shared_ptr<PendingWantKey> &key)
163{
164    if (!inputKey || !key) {
165        TAG_LOGW(AAFwkTag::WANTAGENT, "inputKey or key null");
166        return false;
167    }
168    if (inputKey->GetAppIndex() != key->GetAppIndex()) {
169        return false;
170    }
171    if (inputKey->GetBundleName().compare(key->GetBundleName()) != 0) {
172        return false;
173    }
174    if (inputKey->GetType() != key->GetType()) {
175        return false;
176    }
177    if (inputKey->GetRequestWho().compare(key->GetRequestWho()) != 0) {
178        return false;
179    }
180    if (inputKey->GetRequestCode() != key->GetRequestCode()) {
181        return false;
182    }
183
184    if (inputKey->GetRequestResolvedType().compare(key->GetRequestResolvedType()) != 0) {
185        return false;
186    }
187    if (inputKey->GetUserId() != key->GetUserId()) {
188        return false;
189    }
190
191    if (!inputKey->IsEqualsRequestWant(key->GetRequestWantRef())) {
192        return false;
193    }
194
195    return true;
196}
197
198int32_t PendingWantManager::SendWantSender(sptr<IWantSender> target, const SenderInfo &senderInfo)
199{
200    if (target == nullptr) {
201        if (senderInfo.finishedReceiver != nullptr) {
202            Want want;
203            WantParams wantParams = {};
204            senderInfo.finishedReceiver->PerformReceive(want, senderInfo.code, "canceled", wantParams, false, false, 0);
205        }
206        TAG_LOGE(AAFwkTag::WANTAGENT, "null sender");
207        return ERR_INVALID_VALUE;
208    }
209    sptr<IRemoteObject> obj = target->AsObject();
210    if (obj == nullptr || obj->IsProxyObject()) {
211        if (senderInfo.finishedReceiver != nullptr) {
212            Want want;
213            WantParams wantParams = {};
214            senderInfo.finishedReceiver->PerformReceive(want, senderInfo.code, "canceled", wantParams, false, false, 0);
215        }
216        TAG_LOGE(AAFwkTag::WANTAGENT, "target object null or a proxy");
217        return ERR_INVALID_VALUE;
218    }
219    sptr<PendingWantRecord> record = iface_cast<PendingWantRecord>(obj);
220    SenderInfo info = senderInfo;
221    return record->SenderInner(info);
222}
223
224void PendingWantManager::CancelWantSender(const bool isSystemApp, const sptr<IWantSender> &sender)
225{
226    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
227
228    if (sender == nullptr) {
229        TAG_LOGE(AAFwkTag::WANTAGENT, "null sender");
230        return;
231    }
232
233    auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
234    if (!isSaCall && !isSystemApp) {
235        TAG_LOGE(AAFwkTag::WANTAGENT, "cannot send");
236        return;
237    }
238
239    sptr<IRemoteObject> obj = sender->AsObject();
240    if (obj == nullptr || obj->IsProxyObject()) {
241        TAG_LOGE(AAFwkTag::WANTAGENT, "target object null or a proxy");
242        return;
243    }
244    sptr<PendingWantRecord> record = iface_cast<PendingWantRecord>(obj);
245    CancelWantSenderLocked(*record, true);
246}
247
248void PendingWantManager::CancelWantSenderLocked(PendingWantRecord &record, bool cleanAbility)
249{
250    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
251    std::lock_guard<ffrt::mutex> locker(mutex_);
252    MakeWantSenderCanceledLocked(record);
253    if (cleanAbility) {
254        wantRecords_.erase(record.GetKey());
255        if (record.GetKey() != nullptr) {
256            EraseBundleRecord(record.GetKey()->GetAllWantsInfos(), record.GetKey());
257        }
258    }
259}
260
261int32_t PendingWantManager::DeviceIdDetermine(const Want &want, const sptr<StartOptions> &startOptions,
262    const sptr<IRemoteObject> &callerToken, int32_t requestCode, const int32_t callerUid, int32_t callerTokenId)
263{
264    int32_t result = ERR_OK;
265    std::string localDeviceId;
266    DelayedSingleton<AbilityManagerService>::GetInstance()->GetLocalDeviceId(localDeviceId);
267    if (want.GetElement().GetDeviceID() == "" || want.GetElement().GetDeviceID() == localDeviceId) {
268        if (!startOptions) {
269            result = DelayedSingleton<AbilityManagerService>::GetInstance()->StartAbilityWithSpecifyTokenIdInner(
270                want, callerToken, callerTokenId, true, requestCode, callerUid);
271        } else {
272            TAG_LOGD(AAFwkTag::WANTAGENT, "StartOptions windowMode:%{public}d displayId:%{public}d \
273                withAnimation:%{public}d windowLeft:%{public}d windowTop:%{public}d windowWidth:%{public}d \
274                windowHeight:%{public}d",
275                startOptions->GetWindowMode(), startOptions->GetDisplayID(), startOptions->GetWithAnimation(),
276                startOptions->GetWindowLeft(), startOptions->GetWindowTop(), startOptions->GetWindowWidth(),
277                startOptions->GetWindowHeight());
278            result = DelayedSingleton<AbilityManagerService>::GetInstance()->StartAbilityWithSpecifyTokenIdInner(
279                want, *startOptions, callerToken, true, requestCode, callerUid, callerTokenId);
280        }
281
282        if (result != ERR_OK && result != START_ABILITY_WAITING) {
283            TAG_LOGE(AAFwkTag::WANTAGENT, "startAbility failed");
284        }
285        return result;
286    }
287
288    sptr<IRemoteObject> remoteObject =
289        OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->GetSystemAbility(DISTRIBUTED_SCHED_SA_ID);
290    if (remoteObject == nullptr) {
291        TAG_LOGE(AAFwkTag::WANTAGENT, "GetSystemAbility failed");
292        result = ERR_INVALID_VALUE;
293        return result;
294    }
295    DistributedClient dmsClient;
296    uint32_t accessToken = IPCSkeleton::GetCallingTokenID();
297    int32_t callingUid = IPCSkeleton::GetCallingUid();
298    result = dmsClient.StartRemoteAbility(want, callingUid, requestCode, accessToken);
299    if (result != ERR_OK) {
300        TAG_LOGE(AAFwkTag::WANTAGENT, "StartRemoteAbility failed result = %{public}d", result);
301    }
302
303    return result;
304}
305
306int32_t PendingWantManager::PendingWantStartAbility(const Want &want, const sptr<StartOptions> &startOptions,
307    const sptr<IRemoteObject> &callerToken, int32_t requestCode, const int32_t callerUid, int32_t callerTokenId)
308{
309    TAG_LOGI(AAFwkTag::WANTAGENT, "begin");
310    if (!CheckCallerPermission()) {
311        return ERR_INVALID_VALUE;
312    }
313    int32_t result = DeviceIdDetermine(want, startOptions, callerToken, requestCode, callerUid, callerTokenId);
314    return result;
315}
316
317int32_t PendingWantManager::PendingWantStartServiceExtension(Want &want, const sptr<IRemoteObject> &callerToken)
318{
319    TAG_LOGI(AAFwkTag::WANTAGENT, "called");
320    if (!PermissionVerification::GetInstance()->IsSystemAppCall()
321        && !PermissionVerification::GetInstance()->IsSACall()) {
322        TAG_LOGE(AAFwkTag::WANTAGENT, "non-system app called");
323        return ERR_INVALID_VALUE;
324    }
325    //reset flags
326    want.SetFlags(0);
327    return DelayedSingleton<AbilityManagerService>::GetInstance()->StartExtensionAbility(want, callerToken);
328}
329
330int32_t PendingWantManager::PendingWantStartAbilitys(const std::vector<WantsInfo> &wantsInfo,
331    const sptr<StartOptions> &startOptions, const sptr<IRemoteObject> &callerToken, int32_t requestCode,
332    const int32_t callerUid, int32_t callerTokenId)
333{
334    TAG_LOGI(AAFwkTag::WANTAGENT, "begin");
335
336    if (!CheckCallerPermission()) {
337        return ERR_INVALID_VALUE;
338    }
339    int32_t result = ERR_OK;
340    for (const auto &item : wantsInfo) {
341        auto res = DeviceIdDetermine(item.want, startOptions, callerToken, requestCode, callerUid, callerTokenId);
342        if (res != ERR_OK && res != START_ABILITY_WAITING) {
343            result = res;
344        }
345    }
346    return result;
347}
348
349int32_t PendingWantManager::PendingWantPublishCommonEvent(
350    const Want &want, const SenderInfo &senderInfo, int32_t callerUid, int32_t callerTokenId)
351{
352    TAG_LOGI(AAFwkTag::WANTAGENT, "begin");
353
354    CommonEventData eventData;
355    eventData.SetWant(want);
356    eventData.SetCode(senderInfo.code);
357
358    CommonEventPublishInfo eventPublishData;
359
360    if (!want.GetBundle().empty()) {
361        TAG_LOGI(AAFwkTag::WANTAGENT, "eventPublishData set bundleName: %{public}s", want.GetBundle().c_str());
362        eventPublishData.SetBundleName(want.GetBundle());
363    }
364
365    if (!senderInfo.requiredPermission.empty()) {
366        std::vector<std::string> permissions;
367        permissions.emplace_back(senderInfo.requiredPermission);
368        eventPublishData.SetSubscriberPermissions(permissions);
369    }
370
371    bool result = IN_PROCESS_CALL(DelayedSingleton<EventFwk::CommonEvent>::GetInstance()->PublishCommonEvent(
372        eventData, eventPublishData, nullptr, callerUid, callerTokenId));
373    return ((result == true) ? ERR_OK : (-1));
374}
375
376int32_t PendingWantManager::PendingRecordIdCreate()
377{
378    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
379
380    static std::atomic_int id(0);
381    return ++id;
382}
383
384sptr<PendingWantRecord> PendingWantManager::GetPendingWantRecordByCode(int32_t code)
385{
386    HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
387
388    std::lock_guard<ffrt::mutex> locker(mutex_);
389    auto iter = std::find_if(wantRecords_.begin(), wantRecords_.end(), [&code](const auto &pair) {
390        return pair.second->GetKey()->GetCode() == code;
391    });
392    return ((iter == wantRecords_.end()) ? nullptr : iter->second);
393}
394
395int32_t PendingWantManager::GetPendingWantUid(const sptr<IWantSender> &target)
396{
397    if (target == nullptr) {
398        TAG_LOGE(AAFwkTag::WANTAGENT, "null target");
399        return -1;
400    }
401    sptr<IRemoteObject> obj = target->AsObject();
402    if (obj == nullptr || obj->IsProxyObject()) {
403        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
404        return -1;
405    }
406
407    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
408    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
409    return ((record != nullptr) ? (record->GetUid()) : (-1));
410}
411
412int32_t PendingWantManager::GetPendingWantUserId(const sptr<IWantSender> &target)
413{
414    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
415
416    if (target == nullptr) {
417        TAG_LOGE(AAFwkTag::WANTAGENT, "null target");
418        return -1;
419    }
420    sptr<IRemoteObject> obj = target->AsObject();
421    if (obj == nullptr || obj->IsProxyObject()) {
422        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
423        return -1;
424    }
425    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
426    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
427    return ((record != nullptr) ? (record->GetKey()->GetUserId()) : (-1));
428}
429
430std::string PendingWantManager::GetPendingWantBundleName(const sptr<IWantSender> &target)
431{
432    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
433
434    if (target == nullptr) {
435        TAG_LOGE(AAFwkTag::WANTAGENT, "null target");
436        return "";
437    }
438    sptr<IRemoteObject> obj = target->AsObject();
439    if (obj == nullptr || obj->IsProxyObject()) {
440        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
441        return "";
442    }
443
444    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
445    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
446    if (record != nullptr) {
447        return record->GetKey()->GetBundleName();
448    }
449    return "";
450}
451
452int32_t PendingWantManager::GetPendingWantCode(const sptr<IWantSender> &target)
453{
454    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
455
456    if (target == nullptr) {
457        TAG_LOGE(AAFwkTag::WANTAGENT, "null target");
458        return -1;
459    }
460    sptr<IRemoteObject> obj = target->AsObject();
461    if (obj == nullptr || obj->IsProxyObject()) {
462        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
463        return -1;
464    }
465
466    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
467    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
468    return ((record != nullptr) ? (record->GetKey()->GetCode()) : (-1));
469}
470
471int32_t PendingWantManager::GetPendingWantType(const sptr<IWantSender> &target)
472{
473    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
474
475    if (target == nullptr) {
476        TAG_LOGE(AAFwkTag::WANTAGENT, "null target");
477        return -1;
478    }
479    sptr<IRemoteObject> obj = target->AsObject();
480    if (obj == nullptr || obj->IsProxyObject()) {
481        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
482        return -1;
483    }
484
485    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
486    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
487    return ((record != nullptr) ? (record->GetKey()->GetType()) : (-1));
488}
489
490void PendingWantManager::RegisterCancelListener(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &recevier)
491{
492    TAG_LOGI(AAFwkTag::WANTAGENT, "begin");
493
494    if ((sender == nullptr) || (recevier == nullptr)) {
495        TAG_LOGE(AAFwkTag::WANTAGENT, "sender or recevier null");
496        return;
497    }
498    sptr<IRemoteObject> obj = sender->AsObject();
499    if (obj == nullptr || obj->IsProxyObject()) {
500        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
501        return;
502    }
503
504    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
505    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
506    if (record == nullptr) {
507        TAG_LOGE(AAFwkTag::WANTAGENT, "null record. code = %{public}d",
508            targetRecord->GetKey()->GetCode());
509        return;
510    }
511    bool cancel = record->GetCanceled();
512    std::lock_guard<ffrt::mutex> locker(mutex_);
513    if (!cancel) {
514        record->RegisterCancelListener(recevier);
515    }
516}
517
518void PendingWantManager::UnregisterCancelListener(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &recevier)
519{
520    if (sender == nullptr || recevier == nullptr) {
521        TAG_LOGE(AAFwkTag::WANTAGENT, "sender or recevier null");
522        return;
523    }
524    sptr<IRemoteObject> obj = sender->AsObject();
525    if (obj == nullptr || obj->IsProxyObject()) {
526        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
527        return;
528    }
529
530    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
531    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
532    if (record == nullptr) {
533        TAG_LOGE(AAFwkTag::WANTAGENT, "null record");
534        return;
535    }
536    std::lock_guard<ffrt::mutex> locker(mutex_);
537    record->UnregisterCancelListener(recevier);
538}
539
540int32_t PendingWantManager::GetPendingRequestWant(const sptr<IWantSender> &target, std::shared_ptr<Want> &want)
541{
542    HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
543    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
544    if (target == nullptr) {
545        TAG_LOGE(AAFwkTag::WANTAGENT, "null target");
546        return ERR_INVALID_VALUE;
547    }
548    sptr<IRemoteObject> obj = target->AsObject();
549    if (obj == nullptr || obj->IsProxyObject()) {
550        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
551        return ERR_INVALID_VALUE;
552    }
553
554    if (want == nullptr) {
555        TAG_LOGE(AAFwkTag::WANTAGENT, "null want");
556        return ERR_INVALID_VALUE;
557    }
558    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
559
560    if (targetRecord == nullptr) {
561        TAG_LOGE(AAFwkTag::WANTAGENT, "null targetRecord");
562        return ERR_INVALID_VALUE;
563    }
564
565    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
566    if (record == nullptr) {
567        TAG_LOGE(AAFwkTag::WANTAGENT, "null record");
568        return ERR_INVALID_VALUE;
569    }
570    want.reset(new (std::nothrow) Want(record->GetKey()->GetRequestWant()));
571    return NO_ERROR;
572}
573
574int32_t PendingWantManager::GetWantSenderInfo(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info)
575{
576    TAG_LOGD(AAFwkTag::WANTAGENT, "begin");
577    if (target == nullptr) {
578        TAG_LOGE(AAFwkTag::WANTAGENT, "null target");
579        return ERR_INVALID_VALUE;
580    }
581    sptr<IRemoteObject> obj = target->AsObject();
582    if (obj == nullptr || obj->IsProxyObject()) {
583        TAG_LOGE(AAFwkTag::WANTAGENT, "target obj null or a proxy object");
584        return ERR_INVALID_VALUE;
585    }
586    if (info == nullptr) {
587        TAG_LOGE(AAFwkTag::WANTAGENT, "null info");
588        return ERR_INVALID_VALUE;
589    }
590    sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(obj);
591    auto record = GetPendingWantRecordByCode(targetRecord->GetKey()->GetCode());
592    if (record == nullptr) {
593        TAG_LOGE(AAFwkTag::WANTAGENT, "null record");
594        return ERR_INVALID_VALUE;
595    }
596    WantSenderInfo wantSenderInfo;
597    wantSenderInfo.requestCode = record->GetKey()->GetRequestCode();
598    wantSenderInfo.type = record->GetKey()->GetType();
599    wantSenderInfo.flags = (uint32_t)(record->GetKey()->GetFlags());
600    wantSenderInfo.allWants = record->GetKey()->GetAllWantsInfos();
601    info.reset(new (std::nothrow) WantSenderInfo(wantSenderInfo));
602    return NO_ERROR;
603}
604
605void PendingWantManager::ClearPendingWantRecord(const std::string &bundleName, int32_t uid)
606{
607    auto abilityManagerService = DelayedSingleton<AbilityManagerService>::GetInstance();
608    CHECK_POINTER(abilityManagerService);
609    auto handler = abilityManagerService->GetTaskHandler();
610    CHECK_POINTER(handler);
611    auto task = [bundleName, uid, self = shared_from_this()]() { self->ClearPendingWantRecordTask(bundleName, uid); };
612    handler->SubmitTask(task);
613}
614
615void PendingWantManager::ClearPendingWantRecordTask(const std::string &bundleName, int32_t uid)
616{
617    if (!QueryRecordByBundle(bundleName)) {
618        return;
619    }
620    std::lock_guard<ffrt::mutex> locker(mutex_);
621    if (!QueryRecordByBundle(bundleName)) {
622        return;
623    }
624    auto iter = wantRecords_.begin();
625    while (iter != wantRecords_.end()) {
626        bool hasBundle = false;
627        const auto &pendingRecord = iter->second;
628        if ((pendingRecord != nullptr)) {
629            auto wantInfos = pendingRecord->GetKey()->GetAllWantsInfos();
630            for (const auto &wantInfo: wantInfos) {
631                if (wantInfo.want.GetBundle() == bundleName && uid == pendingRecord->GetUid()) {
632                    hasBundle = true;
633                    break;
634                }
635            }
636            if (hasBundle) {
637                EraseBundleRecord(wantInfos, pendingRecord->GetKey());
638                iter = wantRecords_.erase(iter);
639                TAG_LOGI(AAFwkTag::WANTAGENT, "wantRecords_ size %{public}zu", wantRecords_.size());
640            } else {
641                ++iter;
642            }
643        } else {
644            ++iter;
645        }
646    }
647}
648
649bool PendingWantManager::CheckCallerPermission()
650{
651    auto callerPid = IPCSkeleton::GetCallingPid();
652    AppExecFwk::RunningProcessInfo processInfo;
653    DelayedSingleton<AppScheduler>::GetInstance()->GetRunningProcessInfoByPid(callerPid, processInfo);
654    auto permission = DelayedSingleton<PermissionVerification>::GetInstance();
655    if (permission == nullptr) {
656        TAG_LOGE(AAFwkTag::WANTAGENT, "null permission");
657        return false;
658    }
659    if ((!processInfo.isFocused && !processInfo.isAbilityForegrounding) ||
660        (!permission->IsSystemAppCall() && !CheckWindowState(callerPid))) {
661        TAG_LOGW(AAFwkTag::WANTAGENT, "caller unfocused");
662        if (!permission->VerifyCallingPermission(PermissionConstants::PERMISSION_START_ABILITIES_FROM_BACKGROUND) &&
663            !permission->VerifyCallingPermission(PermissionConstants::PERMISSION_START_ABILIIES_FROM_BACKGROUND) &&
664            !permission->IsSACall()) {
665            TAG_LOGW(AAFwkTag::WANTAGENT, "caller PERMISSION_DENIED");
666            return false;
667        }
668    }
669    return true;
670}
671
672bool PendingWantManager::CheckWindowState(int32_t pid)
673{
674    auto sceneSessionManager = Rosen::SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
675    if (sceneSessionManager == nullptr) {
676        TAG_LOGE(AAFwkTag::WANTAGENT, "null manager");
677        return false;
678    }
679    std::vector<Rosen::MainWindowState> windowStates;
680    Rosen::WSError ret = sceneSessionManager->GetMainWindowStatesByPid(pid, windowStates);
681    if (ret != Rosen::WSError::WS_OK) {
682        TAG_LOGE(AAFwkTag::WANTAGENT, "fail GetWindow");
683        return false;
684    }
685    for (auto &windowState : windowStates) {
686        if (!windowState.isPcOrPadEnableActivation_ && !windowState.isForegroundInteractive_) {
687            TAG_LOGD(AAFwkTag::WANTAGENT, "window interactive");
688            return false;
689        }
690    }
691    return true;
692}
693
694void PendingWantManager::Dump(std::vector<std::string> &info)
695{
696    TAG_LOGD(AAFwkTag::WANTAGENT, "dump begin");
697    std::string dumpInfo = "    PendingWantRecords:";
698    info.push_back(dumpInfo);
699
700    for (const auto &item : wantRecords_) {
701        const auto &pendingKey = item.first;
702        dumpInfo = "        PendWantRecord ID #" + std::to_string(pendingKey->GetCode()) +
703            "  type #" + std::to_string(pendingKey->GetType());
704        info.push_back(dumpInfo);
705        dumpInfo = "        bundle name [" + pendingKey->GetBundleName() + "]";
706        info.push_back(dumpInfo);
707        dumpInfo = "        result who [" + pendingKey->GetRequestWho() + "]";
708        info.push_back(dumpInfo);
709        dumpInfo = "        request code #" + std::to_string(pendingKey->GetRequestCode()) +
710            "  flags #" + std::to_string(pendingKey->GetFlags());
711        info.push_back(dumpInfo);
712        dumpInfo = "        resolved type [" + pendingKey->GetRequestResolvedType() + "]";
713        info.push_back(dumpInfo);
714        dumpInfo = "        Wants:";
715        info.push_back(dumpInfo);
716        auto Wants = pendingKey->GetAllWantsInfos();
717        for (const auto &Want : Wants) {
718            dumpInfo = "          uri [" + Want.want.GetElement().GetDeviceID() + "//" +
719                Want.want.GetElement().GetBundleName() + "/" + Want.want.GetElement().GetAbilityName() + "]";
720            info.push_back(dumpInfo);
721            dumpInfo = "          resolved types [" + Want.resolvedTypes + "]";
722            info.push_back(dumpInfo);
723        }
724    }
725}
726void PendingWantManager::DumpByRecordId(std::vector<std::string> &info, const std::string &args)
727{
728    TAG_LOGD(AAFwkTag::WANTAGENT, "dump by id begin");
729    std::string dumpInfo = "    PendingWantRecords:";
730    info.push_back(dumpInfo);
731
732    for (const auto &item : wantRecords_) {
733        const auto &pendingKey = item.first;
734        if (args == std::to_string(pendingKey->GetCode())) {
735            dumpInfo = "        PendWantRecord ID #" + std::to_string(pendingKey->GetCode()) +
736                "  type #" + std::to_string(pendingKey->GetType());
737                info.push_back(dumpInfo);
738                dumpInfo = "        bundle name [" + pendingKey->GetBundleName() + "]";
739                info.push_back(dumpInfo);
740                dumpInfo = "        result who [" + pendingKey->GetRequestWho() + "]";
741                info.push_back(dumpInfo);
742                dumpInfo = "        request code #" + std::to_string(pendingKey->GetRequestCode()) +
743                "  flags #" + std::to_string(pendingKey->GetFlags());
744                info.push_back(dumpInfo);
745            dumpInfo = "        resolved type [" + pendingKey->GetRequestResolvedType() + "]";
746            info.push_back(dumpInfo);
747            dumpInfo = "        Wants:";
748            info.push_back(dumpInfo);
749            auto Wants = pendingKey->GetAllWantsInfos();
750            for (const auto& Want : Wants) {
751                dumpInfo = "          uri [" + Want.want.GetElement().GetDeviceID() + "//" +
752                    Want.want.GetElement().GetBundleName() + "/" + Want.want.GetElement().GetAbilityName() + "]";
753                info.push_back(dumpInfo);
754                dumpInfo = "          resolved types [" + Want.resolvedTypes + "]";
755                info.push_back(dumpInfo);
756            }
757        }
758    }
759}
760
761int32_t PendingWantManager::GetAllRunningInstanceKeysByBundleName(
762    const std::string &bundleName, std::vector<std::string> &appKeyVec)
763{
764    if (bundleName.empty()) {
765        TAG_LOGE(AAFwkTag::WANTAGENT, "bundle name is empty");
766        return ERR_INVALID_VALUE;
767    }
768
769    auto appMgr = AppMgrUtil::GetAppMgr();
770    if (appMgr == nullptr) {
771        TAG_LOGE(AAFwkTag::WANTAGENT, "app mgr is null");
772        return OBJECT_NULL;
773    }
774
775    return IN_PROCESS_CALL(appMgr->GetAllRunningInstanceKeysByBundleName(bundleName, appKeyVec));
776}
777
778void PendingWantManager::EraseBundleRecord(
779    const std::vector<WantsInfo> &wantsInfos, std::shared_ptr<PendingWantKey> key)
780{
781    std::lock_guard<ffrt::mutex> locker(bundleRecordsMutex_);
782    for (const auto &wantInfo : wantsInfos) {
783        auto it = bundleRecords_.find(wantInfo.want.GetBundle());
784        if (it != bundleRecords_.end()) {
785            auto &recordVec = it->second;
786            recordVec.erase(std::remove_if(recordVec.begin(), recordVec.end(),
787                [key](std::shared_ptr<PendingWantKey> value) {
788                    return value == key;
789                }),
790                recordVec.end());
791            if (recordVec.empty()) {
792                bundleRecords_.erase(wantInfo.want.GetBundle());
793            }
794        }
795    }
796}
797
798void PendingWantManager::InsertBundleRecord(
799    const std::vector<WantsInfo> &wantsInfos, std::shared_ptr<PendingWantKey> key)
800{
801    std::lock_guard<ffrt::mutex> locker(bundleRecordsMutex_);
802    for (const auto &wantInfo : wantsInfos) {
803        auto it = bundleRecords_.find(wantInfo.want.GetBundle());
804        if (it != bundleRecords_.end()) {
805            auto &recordVec = it->second;
806            recordVec.emplace_back(key);
807        } else {
808            std::vector<std::shared_ptr<PendingWantKey>> pendingWantVector;
809            pendingWantVector.emplace_back(key);
810            bundleRecords_[wantInfo.want.GetBundle()] = pendingWantVector;
811        }
812    }
813}
814
815bool PendingWantManager::QueryRecordByBundle(const std::string &bundleName)
816{
817    std::lock_guard<ffrt::mutex> locker(bundleRecordsMutex_);
818    auto bundleIter = bundleRecords_.find(bundleName);
819    if (bundleIter != bundleRecords_.end()) {
820        return true;
821    }
822    return false;
823}
824}  // namespace AAFwk
825}  // namespace OHOS
826