• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "common_event_control_manager.h"
17 
18 #include <cinttypes>
19 
20 #include "access_token_helper.h"
21 #include "bundle_manager_helper.h"
22 #include "common_event_constant.h"
23 #include "event_log_wrapper.h"
24 #include "event_report.h"
25 #include "hitrace_meter_adapter.h"
26 #include "ievent_receive.h"
27 #include "system_time.h"
28 #include "xcollie/watchdog.h"
29 
30 namespace OHOS {
31 namespace EventFwk {
32 constexpr int32_t LENGTH = 80;
33 constexpr int32_t DOUBLE = 2;
34 const std::string CONNECTOR = " or ";
35 static const int32_t TIME_UNIT_SIZE = 1000;
36 
CommonEventControlManager()37 CommonEventControlManager::CommonEventControlManager()
38     : handler_(nullptr), handlerOrdered_(nullptr), pendingTimeoutMessage_(false), scheduled_(false)
39 {
40     EVENT_LOGD("enter");
41 }
42 
~CommonEventControlManager()43 CommonEventControlManager::~CommonEventControlManager()
44 {
45     EVENT_LOGD("enter");
46 }
47 
PublishCommonEvent(const CommonEventRecord & eventRecord,const sptr<IRemoteObject> & commonEventListener)48 bool CommonEventControlManager::PublishCommonEvent(
49     const CommonEventRecord &eventRecord, const sptr<IRemoteObject> &commonEventListener)
50 {
51     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
52     EVENT_LOGD("enter");
53 
54     bool ret = false;
55 
56     if (!eventRecord.publishInfo->IsOrdered()) {
57         ret = ProcessUnorderedEvent(eventRecord);
58     } else {
59         ret = ProcessOrderedEvent(eventRecord, commonEventListener);
60     }
61 
62     return ret;
63 }
64 
PublishStickyCommonEvent(const CommonEventRecord & eventRecord,const std::shared_ptr<EventSubscriberRecord> & subscriberRecord)65 bool CommonEventControlManager::PublishStickyCommonEvent(
66     const CommonEventRecord &eventRecord, const std::shared_ptr<EventSubscriberRecord> &subscriberRecord)
67 {
68     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
69     EVENT_LOGD("enter");
70 
71     if (!subscriberRecord) {
72         EVENT_LOGE("subscriberRecord is null");
73         return false;
74     }
75     return ProcessUnorderedEvent(eventRecord, subscriberRecord);
76 }
77 
PublishFreezeCommonEvent(const uid_t & uid)78 bool CommonEventControlManager::PublishFreezeCommonEvent(const uid_t &uid)
79 {
80     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
81     EVENT_LOGD("enter");
82 
83     if (!GetUnorderedEventHandler()) {
84         EVENT_LOGE("failed to get eventhandler");
85         return false;
86     }
87     PublishFrozenEventsInner(DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->GetFrozenEvents(uid));
88     return true;
89 }
90 
PublishFreezeCommonEvent(std::set<int> pidList)91 bool CommonEventControlManager::PublishFreezeCommonEvent(std::set<int> pidList)
92 {
93     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
94     EVENT_LOGD("enter");
95 
96     if (!GetUnorderedEventHandler()) {
97         EVENT_LOGE("failed to get eventhandler");
98         return false;
99     }
100     for (auto it = pidList.begin(); it != pidList.end(); it++) {
101         PublishFrozenEventsInner(
102             DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->GetFrozenEventsMapByPid(*it));
103     }
104     return true;
105 }
106 
PublishAllFreezeCommonEvents()107 bool CommonEventControlManager::PublishAllFreezeCommonEvents()
108 {
109     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
110     EVENT_LOGD("enter");
111 
112     if (!GetUnorderedEventHandler()) {
113         EVENT_LOGE("failed to get eventhandler");
114         return false;
115     }
116 
117     std::map<uid_t, FrozenRecords> frozenEventRecords =
118         DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->GetAllFrozenEvents();
119     for (auto record : frozenEventRecords) {
120         PublishFrozenEventsInner(record.second);
121     }
122 
123     std::map<pid_t, FrozenRecords> frozenEventRecordsMap =
124         DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->GetAllFrozenEventsMap();
125     for (auto record : frozenEventRecordsMap) {
126         PublishFrozenEventsInner(record.second);
127     }
128     return true;
129 }
130 
PublishFrozenEventsInner(const FrozenRecords & frozenRecords)131 void CommonEventControlManager::PublishFrozenEventsInner(const FrozenRecords &frozenRecords)
132 {
133     for (auto record : frozenRecords) {
134         for (auto vec : record.second) {
135             if (!vec) {
136                 EVENT_LOGW("failed to find record");
137                 continue;
138             }
139 
140             EventSubscriberRecord subscriberRecord = record.first;
141             CommonEventRecord eventRecord = *vec;
142             std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
143             auto innerCallback = [weak, subscriberRecord, eventRecord]() {
144                 auto control = weak.lock();
145                 if (control == nullptr) {
146                     EVENT_LOGE("CommonEventControlManager is null");
147                     return;
148                 }
149                 control->NotifyFreezeEvents(subscriberRecord, eventRecord);
150             };
151             unorderedImmediateQueue_->submit(innerCallback);
152         }
153     }
154 }
155 
NotifyFreezeEvents(const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)156 bool CommonEventControlManager::NotifyFreezeEvents(
157     const EventSubscriberRecord &subscriberRecord, const CommonEventRecord &eventRecord)
158 {
159     EVENT_LOGD("enter");
160 
161     sptr<IEventReceive> commonEventListenerProxy = iface_cast<IEventReceive>(subscriberRecord.commonEventListener);
162     if (!commonEventListenerProxy) {
163         EVENT_LOGE("Fail to get IEventReceive proxy");
164         return false;
165     }
166 
167     int8_t ret = CheckPermission(subscriberRecord, eventRecord);
168     if (ret != OrderedEventRecord::DELIVERED) {
169         EVENT_LOGE("check permission is failed");
170         return false;
171     }
172     if (eventRecord.commonEventData == nullptr) {
173         EVENT_LOGE("commonEventData == nullptr");
174         return false;
175     }
176     EVENT_LOGI("Send %{public}s to subscriber %{public}s (pid = %{public}d, uid = %{public}d) when unfreezed",
177         eventRecord.commonEventData->GetWant().GetAction().c_str(),
178         subscriberRecord.eventRecordInfo.bundleName.c_str(),
179         subscriberRecord.eventRecordInfo.pid,
180         subscriberRecord.eventRecordInfo.uid);
181     commonEventListenerProxy->NotifyEvent(*(eventRecord.commonEventData),
182         false, eventRecord.publishInfo->IsSticky());
183     AccessTokenHelper::RecordSensitivePermissionUsage(subscriberRecord.eventRecordInfo.callerToken,
184         eventRecord.commonEventData->GetWant().GetAction());
185     return true;
186 }
187 
GetUnorderedEventHandler()188 bool CommonEventControlManager::GetUnorderedEventHandler()
189 {
190     if (!unorderedQueue_) {
191         unorderedQueue_ = std::make_shared<ffrt::queue>("unordered_common_event");
192     }
193 
194     if (!unorderedImmediateQueue_) {
195         unorderedImmediateQueue_ = std::make_shared<ffrt::queue>("unordered_immediate_common_event",
196             ffrt::queue_attr().qos(ffrt::qos_utility));
197     }
198 
199     return true;
200 }
201 
NotifyUnorderedEventLocked(std::shared_ptr<OrderedEventRecord> & eventRecord)202 void CommonEventControlManager::NotifyUnorderedEventLocked(std::shared_ptr<OrderedEventRecord> &eventRecord)
203 {
204     int32_t succCnt = 0;
205     int32_t failCnt = 0;
206     int32_t freezeCnt = 0;
207     for (auto vec : eventRecord->receivers) {
208         if (vec == nullptr) {
209             EVENT_LOGE("invalid vec");
210             failCnt++;
211             continue;
212         }
213         size_t index = eventRecord->nextReceiver++;
214         if (vec->isFreeze) {
215             eventRecord->deliveryState[index] = OrderedEventRecord::SKIPPED;
216             DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->InsertFrozenEvents(vec, *eventRecord);
217             DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->InsertFrozenEventsMap(
218                 vec, *eventRecord);
219             EVENT_LOGE("Notify %{public}s to freeze subscriber, subId = %{public}s",
220                 eventRecord->commonEventData->GetWant().GetAction().c_str(), vec->eventRecordInfo.subId.c_str());
221             freezeCnt++;
222         } else {
223             sptr<IEventReceive> commonEventListenerProxy = iface_cast<IEventReceive>(vec->commonEventListener);
224             if (!commonEventListenerProxy) {
225                 eventRecord->deliveryState[index] = OrderedEventRecord::SKIPPED;
226                 EVENT_LOGE("Notify %{public}s to invalid proxy, subId = %{public}s",
227                     eventRecord->commonEventData->GetWant().GetAction().c_str(), vec->eventRecordInfo.subId.c_str());
228                 failCnt++;
229                 continue;
230             }
231             int8_t ret = CheckPermission(*vec, *eventRecord);
232             eventRecord->deliveryState[index] = ret;
233             if (ret == OrderedEventRecord::DELIVERED) {
234                 eventRecord->state = OrderedEventRecord::RECEIVING;
235                 commonEventListenerProxy->NotifyEvent(
236                     *(eventRecord->commonEventData), false, eventRecord->publishInfo->IsSticky());
237                 eventRecord->state = OrderedEventRecord::RECEIVED;
238                 succCnt++;
239                 AccessTokenHelper::RecordSensitivePermissionUsage(vec->eventRecordInfo.callerToken,
240                     eventRecord->commonEventData->GetWant().GetAction());
241             } else {
242                 failCnt++;
243                 EVENT_LOGE("Notify %{public}s fail, subId = %{public}s",
244                     eventRecord->commonEventData->GetWant().GetAction().c_str(), vec->eventRecordInfo.subId.c_str());
245             }
246         }
247     }
248     EVENT_LOGI("Notify %{public}s end(%{public}zu, %{public}d, %{public}d, %{public}d)",
249         eventRecord->commonEventData->GetWant().GetAction().c_str(),
250         eventRecord->receivers.size(), succCnt, failCnt, freezeCnt);
251 }
252 
NotifyUnorderedEvent(std::shared_ptr<OrderedEventRecord> & eventRecord)253 bool CommonEventControlManager::NotifyUnorderedEvent(std::shared_ptr<OrderedEventRecord> &eventRecord)
254 {
255     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
256     if (!eventRecord) {
257         EVENT_LOGD("Invalid event record.");
258         return false;
259     }
260 
261     std::lock_guard<std::mutex> lock(unorderedMutex_);
262     NotifyUnorderedEventLocked(eventRecord);
263 
264     auto it = std::find(unorderedEventQueue_.begin(), unorderedEventQueue_.end(), eventRecord);
265     if (it != unorderedEventQueue_.end()) {
266         unorderedEventQueue_.erase(it);
267     }
268     return true;
269 }
270 
ProcessUnorderedEvent(const CommonEventRecord & eventRecord,const std::shared_ptr<EventSubscriberRecord> & subscriberRecord)271 bool CommonEventControlManager::ProcessUnorderedEvent(
272     const CommonEventRecord &eventRecord, const std::shared_ptr<EventSubscriberRecord> &subscriberRecord)
273 {
274     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
275     EVENT_LOGD("enter");
276 
277     bool ret = false;
278 
279     if (!GetUnorderedEventHandler()) {
280         EVENT_LOGE("failed to get eventhandler");
281         return ret;
282     }
283 
284     std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
285     if (eventRecordPtr == nullptr) {
286         EVENT_LOGE("eventRecordPtr is null");
287         return ret;
288     }
289 
290     std::shared_ptr<CommonEventSubscriberManager> spinstance =
291         DelayedSingleton<CommonEventSubscriberManager>::GetInstance();
292 
293     eventRecordPtr->FillCommonEventRecord(eventRecord);
294     if (subscriberRecord) {
295         eventRecordPtr->receivers.emplace_back(subscriberRecord);
296     } else {
297         eventRecordPtr->receivers = spinstance->GetSubscriberRecords(eventRecord);
298     }
299 
300     for (auto vec : eventRecordPtr->receivers) {
301         eventRecordPtr->deliveryState.emplace_back(OrderedEventRecord::PENDING);
302     }
303 
304     EnqueueUnorderedRecord(eventRecordPtr);
305 
306     std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
307     auto innerCallback = [weak, eventRecordPtr]() {
308         auto manager = weak.lock();
309         if (manager == nullptr) {
310             EVENT_LOGE("CommonEventControlManager is null");
311             return;
312         }
313         std::shared_ptr<OrderedEventRecord> ordered = eventRecordPtr;
314         manager->NotifyUnorderedEvent(ordered);
315     };
316 
317     if (eventRecord.isSystemEvent) {
318         unorderedImmediateQueue_->submit(innerCallback);
319     } else {
320         unorderedQueue_->submit(innerCallback);
321     }
322 
323     return ret;
324 }
325 
GetMatchingOrderedReceiver(const sptr<IRemoteObject> & proxy)326 std::shared_ptr<OrderedEventRecord> CommonEventControlManager::GetMatchingOrderedReceiver(
327     const sptr<IRemoteObject> &proxy)
328 {
329     EVENT_LOGD("enter");
330 
331     std::lock_guard<std::mutex> lock(orderedMutex_);
332 
333     if (!orderedEventQueue_.empty()) {
334         std::shared_ptr<OrderedEventRecord> firstRecord = orderedEventQueue_.front();
335         if ((firstRecord != nullptr) && (firstRecord->curReceiver == proxy)) {
336             return firstRecord;
337         }
338     }
339 
340     return nullptr;
341 }
342 
GetOrderedEventHandler()343 bool CommonEventControlManager::GetOrderedEventHandler()
344 {
345     if (!orderedQueue_) {
346         orderedQueue_ = std::make_shared<ffrt::queue>("ordered_common_event");
347     }
348     return true;
349 }
350 
ProcessOrderedEvent(const CommonEventRecord & eventRecord,const sptr<IRemoteObject> & commonEventListener)351 bool CommonEventControlManager::ProcessOrderedEvent(
352     const CommonEventRecord &eventRecord, const sptr<IRemoteObject> &commonEventListener)
353 {
354     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
355     EVENT_LOGD("enter");
356 
357     bool ret = false;
358 
359     if (!GetOrderedEventHandler()) {
360         EVENT_LOGE("failed to get eventhandler");
361         return ret;
362     }
363 
364     std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
365     if (eventRecordPtr == nullptr) {
366         EVENT_LOGE("eventRecordPtr is null");
367         return ret;
368     }
369 
370     std::shared_ptr<CommonEventSubscriberManager> spinstance =
371         DelayedSingleton<CommonEventSubscriberManager>::GetInstance();
372     auto subscribers = spinstance->GetSubscriberRecords(eventRecord);
373     auto OrderedSubscriberCompareFunc = [] (
374         std::shared_ptr<EventSubscriberRecord> fist,
375         std::shared_ptr<EventSubscriberRecord> second) {
376         return fist->eventSubscribeInfo->GetPriority() > second->eventSubscribeInfo->GetPriority();
377     };
378     std::sort(subscribers.begin(), subscribers.end(), OrderedSubscriberCompareFunc);
379     eventRecordPtr->FillCommonEventRecord(eventRecord);
380     eventRecordPtr->resultTo = commonEventListener;
381     eventRecordPtr->state = OrderedEventRecord::IDLE;
382     eventRecordPtr->nextReceiver = 0;
383     eventRecordPtr->receivers = subscribers;
384     for (auto vec : eventRecordPtr->receivers) {
385         eventRecordPtr->deliveryState.emplace_back(OrderedEventRecord::PENDING);
386     }
387 
388     EnqueueOrderedRecord(eventRecordPtr);
389 
390     ret = ScheduleOrderedCommonEvent();
391 
392     return ret;
393 }
394 
EnqueueUnorderedRecord(const std::shared_ptr<OrderedEventRecord> & eventRecordPtr)395 bool CommonEventControlManager::EnqueueUnorderedRecord(const std::shared_ptr<OrderedEventRecord> &eventRecordPtr)
396 {
397     if (eventRecordPtr == nullptr) {
398         EVENT_LOGE("eventRecordPtr is null");
399         return false;
400     }
401 
402     std::lock_guard<std::mutex> lock(unorderedMutex_);
403 
404     unorderedEventQueue_.emplace_back(eventRecordPtr);
405 
406     return true;
407 }
408 
EnqueueOrderedRecord(const std::shared_ptr<OrderedEventRecord> & eventRecordPtr)409 bool CommonEventControlManager::EnqueueOrderedRecord(const std::shared_ptr<OrderedEventRecord> &eventRecordPtr)
410 {
411     if (eventRecordPtr == nullptr) {
412         EVENT_LOGE("eventRecordPtr is null");
413         return false;
414     }
415 
416     std::lock_guard<std::mutex> lock(orderedMutex_);
417 
418     orderedEventQueue_.emplace_back(eventRecordPtr);
419 
420     return true;
421 }
422 
ScheduleOrderedCommonEvent()423 bool CommonEventControlManager::ScheduleOrderedCommonEvent()
424 {
425     EVENT_LOGD("enter");
426 
427     if (scheduled_) {
428         return true;
429     }
430 
431     scheduled_ = true;
432 
433     std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
434     orderedQueue_->submit([weak]() {
435         auto manager = weak.lock();
436         if (manager == nullptr) {
437             EVENT_LOGE("CommonEventControlManager is null");
438             return;
439         }
440         manager->ProcessNextOrderedEvent(true);
441     });
442     return true;
443 }
444 
NotifyOrderedEvent(std::shared_ptr<OrderedEventRecord> & eventRecordPtr,size_t index)445 bool CommonEventControlManager::NotifyOrderedEvent(std::shared_ptr<OrderedEventRecord> &eventRecordPtr, size_t index)
446 {
447     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
448     EVENT_LOGD("enter with index %{public}zu", index);
449     if (eventRecordPtr == nullptr) {
450         EVENT_LOGE("eventRecordPtr = nullptr");
451         return false;
452     }
453     size_t receiverNum = eventRecordPtr->receivers.size();
454     if ((index < 0) || (index >= receiverNum)) {
455         EVENT_LOGE("Invalid index (= %{public}zu)", index);
456         return false;
457     }
458     int8_t ret = CheckPermission(*(eventRecordPtr->receivers[index]), *eventRecordPtr);
459     if (ret == OrderedEventRecord::SKIPPED) {
460         eventRecordPtr->deliveryState[index] = ret;
461         return true;
462     }
463     if (ret == OrderedEventRecord::DELIVERED) {
464         if (eventRecordPtr->receivers[index]->isFreeze) {
465             EVENT_LOGD("vec isFreeze: %{public}d", eventRecordPtr->receivers[index]->isFreeze);
466             DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->InsertFrozenEvents(
467                 eventRecordPtr->receivers[index], *eventRecordPtr);
468             DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->InsertFrozenEventsMap(
469                 eventRecordPtr->receivers[index], *eventRecordPtr);
470             eventRecordPtr->deliveryState[index] = OrderedEventRecord::SKIPPED;
471             eventRecordPtr->curReceiver = nullptr;
472             return true;
473         }
474         eventRecordPtr->deliveryState[index] = ret;
475         eventRecordPtr->curReceiver = eventRecordPtr->receivers[index]->commonEventListener;
476         eventRecordPtr->state = OrderedEventRecord::RECEIVING;
477         sptr<IEventReceive> receiver = iface_cast<IEventReceive>(eventRecordPtr->curReceiver);
478         if (!receiver) {
479             EVENT_LOGE("Failed to get IEventReceive proxy");
480             eventRecordPtr->curReceiver = nullptr;
481             return false;
482         }
483         eventRecordPtr->state = OrderedEventRecord::RECEIVED;
484         receiver->NotifyEvent(*(eventRecordPtr->commonEventData), true, eventRecordPtr->publishInfo->IsSticky());
485         EVENT_LOGD("NotifyOrderedEvent index = %{public}zu event = %{public}s success, subId = %{public}s", index,
486             eventRecordPtr->commonEventData->GetWant().GetAction().c_str(),
487             eventRecordPtr->receivers[index]->eventRecordInfo.subId.c_str());
488         AccessTokenHelper::RecordSensitivePermissionUsage(
489             eventRecordPtr->receivers[index]->eventRecordInfo.callerToken,
490             eventRecordPtr->commonEventData->GetWant().GetAction());
491     }
492     return true;
493 }
494 
ProcessNextOrderedEvent(bool isSendMsg)495 void CommonEventControlManager::ProcessNextOrderedEvent(bool isSendMsg)
496 {
497     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
498     EVENT_LOGD("enter");
499 
500     if (isSendMsg) {
501         scheduled_ = false;
502     }
503 
504     std::shared_ptr<OrderedEventRecord> sp = nullptr;
505 
506     std::lock_guard<std::mutex> lock(orderedMutex_);
507 
508     do {
509         if (orderedEventQueue_.empty()) {
510             EVENT_LOGD("orderedEventQueue_ is empty");
511             return;
512         }
513 
514         sp = orderedEventQueue_.front();
515         bool forceReceive = false;
516         size_t numReceivers = sp->receivers.size();
517         uint64_t nowSysTime = static_cast<uint64_t>(SystemTime::GetNowSysTime());
518 
519         if (sp->dispatchTime > 0) {
520             if ((numReceivers > 0) && (nowSysTime > static_cast<uint64_t>(sp->dispatchTime) +
521                 (DOUBLE * TIMEOUT * numReceivers))) {
522                 CurrentOrderedEventTimeout(false);
523                 forceReceive = true;
524                 sp->state = OrderedEventRecord::IDLE;
525             }
526         }
527 
528         if (sp->state != OrderedEventRecord::IDLE) {
529             return;
530         }
531 
532         if ((sp->receivers.empty()) || (sp->nextReceiver >= numReceivers) || sp->resultAbort || forceReceive) {
533             // No more receivers for this ordered common event, then process the final result receiver
534             bool hasLastSubscribe = (sp->resultTo != nullptr) ? true : false;
535             if (sp->resultTo != nullptr) {
536                 EVENT_LOGD("Process the final subscriber");
537                 sptr<IEventReceive> receiver = iface_cast<IEventReceive>(sp->resultTo);
538                 if (!receiver) {
539                     EVENT_LOGE("Failed to get IEventReceive proxy");
540                     return;
541                 }
542                 receiver->NotifyEvent(*(sp->commonEventData), true, sp->publishInfo->IsSticky());
543                 sp->resultTo = nullptr;
544             }
545             EVENT_LOGI("Notify %{public}s end(%{public}zu, %{public}zu)",
546                 sp->commonEventData->GetWant().GetAction().c_str(), numReceivers, sp->nextReceiver);
547             CancelTimeout();
548 
549             orderedEventQueue_.erase(orderedEventQueue_.begin());
550 
551             sp = nullptr;
552         }
553     } while (sp == nullptr);
554 
555     size_t recIdx = sp->nextReceiver++;
556     SetTime(recIdx, sp, pendingTimeoutMessage_);
557 
558     NotifyOrderedEvent(sp, recIdx);
559     if (sp->curReceiver == nullptr) {
560         sp->state = OrderedEventRecord::IDLE;
561         ScheduleOrderedCommonEvent();
562     }
563 }
564 
SetTime(size_t recIdx,std::shared_ptr<OrderedEventRecord> & sp,bool timeoutMessage)565 void CommonEventControlManager::SetTime(size_t recIdx, std::shared_ptr<OrderedEventRecord> &sp, bool timeoutMessage)
566 {
567     EVENT_LOGD("enter");
568 
569     sp->receiverTime = SystemTime::GetNowSysTime();
570 
571     if (recIdx == 0) {
572         sp->dispatchTime = sp->receiverTime;
573     }
574 
575     if (!timeoutMessage) {
576         SetTimeout();
577     }
578 }
579 
SetTimeout()580 bool CommonEventControlManager::SetTimeout()
581 {
582     EVENT_LOGD("enter");
583 
584     bool ret = true;
585 
586     if (!pendingTimeoutMessage_) {
587         pendingTimeoutMessage_ = true;
588         std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
589         orderedHandler = orderedQueue_->submit_h([weak]() {
590             auto manager = weak.lock();
591             if (manager == nullptr) {
592                 EVENT_LOGE("CommonEventControlManager is null");
593                 return;
594             }
595             manager->CurrentOrderedEventTimeout(true);
596         }, ffrt::task_attr().delay(TIMEOUT * TIME_UNIT_SIZE));
597     }
598 
599     return ret;
600 }
601 
CancelTimeout()602 bool CommonEventControlManager::CancelTimeout()
603 {
604     EVENT_LOGD("enter");
605 
606     if (pendingTimeoutMessage_) {
607         pendingTimeoutMessage_ = false;
608         orderedQueue_->cancel(orderedHandler);
609     }
610 
611     return true;
612 }
613 
CurrentOrderedEventTimeout(bool isFromMsg)614 void CommonEventControlManager::CurrentOrderedEventTimeout(bool isFromMsg)
615 {
616     EVENT_LOGD("enter");
617 
618     if (isFromMsg) {
619         pendingTimeoutMessage_ = false;
620     }
621 
622     if (orderedEventQueue_.empty()) {
623         EVENT_LOGE("empty orderedEventQueue_");
624         return;
625     }
626 
627     int64_t nowSysTime = SystemTime::GetNowSysTime();
628     std::shared_ptr<OrderedEventRecord> sp = orderedEventQueue_.front();
629 
630     if (isFromMsg) {
631         int64_t timeoutTime = sp->receiverTime + TIMEOUT;
632         if (timeoutTime > nowSysTime) {
633             SetTimeout();
634             return;
635         }
636     }
637 
638     // The processing of current receiver has timeout
639     sp->receiverTime = nowSysTime;
640 
641     if (sp->nextReceiver > 0) {
642         std::shared_ptr<EventSubscriberRecord> subscriberRecord = sp->receivers[sp->nextReceiver - 1];
643         EVENT_LOGW("Timeout: When %{public}s (pid = %{public}d, uid = %{public}d) process common event %{public}s",
644             subscriberRecord->eventRecordInfo.bundleName.c_str(),
645             subscriberRecord->eventRecordInfo.pid,
646             subscriberRecord->eventRecordInfo.uid,
647             sp->commonEventData->GetWant().GetAction().c_str());
648         SendOrderedEventProcTimeoutHiSysEvent(subscriberRecord, sp->commonEventData->GetWant().GetAction());
649 
650         sp->deliveryState[sp->nextReceiver - 1] = OrderedEventRecord::TIMEOUT;
651     }
652 
653     // Forced to finish the current receiver to process the next receiver
654     int32_t code = sp->commonEventData->GetCode();
655     const std::string &strRef = sp->commonEventData->GetData();
656     bool abort = sp->resultAbort;
657     FinishReceiver(sp, code, strRef, abort);
658 
659     ScheduleOrderedCommonEvent();
660 
661     return;
662 }
663 
FinishReceiver(std::shared_ptr<OrderedEventRecord> recordPtr,const int32_t & code,const std::string & receiverData,const bool & abortEvent)664 bool CommonEventControlManager::FinishReceiver(std::shared_ptr<OrderedEventRecord> recordPtr, const int32_t &code,
665     const std::string &receiverData, const bool &abortEvent)
666 {
667     EVENT_LOGD("enter");
668 
669     if (recordPtr == nullptr) {
670         EVENT_LOGE("recordPtr is null");
671         return false;
672     }
673 
674     EVENT_LOGD("enter recordPtr->state=%{public}d", recordPtr->state);
675 
676     int8_t state = recordPtr->state;
677     recordPtr->state = OrderedEventRecord::IDLE;
678     recordPtr->curReceiver = nullptr;
679     recordPtr->commonEventData->SetCode(code);
680     recordPtr->commonEventData->SetData(receiverData);
681     recordPtr->resultAbort = abortEvent;
682 
683     return state == OrderedEventRecord::RECEIVED;
684 }
685 
FinishReceiverAction(std::shared_ptr<OrderedEventRecord> recordPtr,const int32_t & code,const std::string & receiverData,const bool & abortEvent)686 bool CommonEventControlManager::FinishReceiverAction(std::shared_ptr<OrderedEventRecord> recordPtr, const int32_t &code,
687     const std::string &receiverData, const bool &abortEvent)
688 {
689     EVENT_LOGD("enter");
690 
691     if (recordPtr == nullptr) {
692         EVENT_LOGE("recordPtr is nullptr");
693         return false;
694     }
695 
696     bool doNext = false;
697     doNext = FinishReceiver(recordPtr, code, receiverData, abortEvent);
698     if (doNext) {
699         ProcessNextOrderedEvent(false);
700     }
701 
702     return true;
703 }
704 
CheckPermission(const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)705 int8_t CommonEventControlManager::CheckPermission(
706     const EventSubscriberRecord &subscriberRecord, const CommonEventRecord &eventRecord)
707 {
708     EVENT_LOGD("enter");
709     if (subscriberRecord.eventRecordInfo.uid == eventRecord.eventRecordInfo.uid) {
710         EVENT_LOGD("CheckPermission subscribe uid = %{public}d, publish uid = %{public}d",
711             subscriberRecord.eventRecordInfo.uid, eventRecord.eventRecordInfo.uid);
712         return OrderedEventRecord::DELIVERED;
713     }
714     bool ret = false;
715     ret = CheckSubscriberPermission(subscriberRecord, eventRecord);
716     if (!ret) {
717         return OrderedEventRecord::SKIPPED;
718     }
719 
720     std::string subscriberRequiredPermission = subscriberRecord.eventSubscribeInfo->GetPermission();
721     ret = CheckSubscriberRequiredPermission(subscriberRequiredPermission, eventRecord, subscriberRecord);
722     if (!ret) {
723         return OrderedEventRecord::SKIPPED;
724     }
725 
726     std::vector<std::string> publisherRequiredPermissions = eventRecord.publishInfo->GetSubscriberPermissions();
727     ret = CheckPublisherRequiredPermissions(publisherRequiredPermissions, subscriberRecord, eventRecord);
728     if (!ret) {
729         return OrderedEventRecord::SKIPPED;
730     }
731 
732     return OrderedEventRecord::DELIVERED;
733 }
734 
CheckSubscriberPermission(const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)735 bool CommonEventControlManager::CheckSubscriberPermission(
736     const EventSubscriberRecord &subscriberRecord, const CommonEventRecord &eventRecord)
737 {
738     EVENT_LOGD("enter");
739     bool ret = false;
740     std::string lackPermission {};
741     std::string event = eventRecord.commonEventData->GetWant().GetAction();
742     bool isSystemAPIEvent = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->IsSystemAPIEvent(event);
743     if (isSystemAPIEvent && !(subscriberRecord.eventRecordInfo.isSubsystem
744         || subscriberRecord.eventRecordInfo.isSystemApp)) {
745         EVENT_LOGW("Invalid permission for system api event.");
746         return false;
747     }
748     Permission permission = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event);
749     if (permission.names.empty()) {
750         return true;
751     }
752 
753     if (permission.names.size() == 1) {
754         ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, permission.names[0]);
755         lackPermission = permission.names[0];
756     } else if (permission.state == PermissionState::AND) {
757         for (auto vec : permission.names) {
758             ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, vec);
759             if (!ret) {
760                 lackPermission = vec;
761                 break;
762             }
763         }
764     } else if (permission.state == PermissionState::OR) {
765         for (auto vec : permission.names) {
766             ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, vec);
767             lackPermission += vec + CONNECTOR;
768             if (ret) {
769                 break;
770             }
771         }
772         lackPermission = lackPermission.substr(0, lackPermission.length() - CONNECTOR.length());
773     } else {
774         EVENT_LOGW("Invalid Permission.");
775         return false;
776     }
777     if (!ret) {
778         EVENT_LOGW("No permission to receive common event %{public}s, "
779                     "due to subscriber %{public}s (pid = %{public}d, uid = %{public}d) lacks "
780                     "the %{public}s permission.",
781             event.c_str(), subscriberRecord.eventRecordInfo.bundleName.c_str(),
782             subscriberRecord.eventRecordInfo.pid, subscriberRecord.eventRecordInfo.uid, lackPermission.c_str());
783     }
784 
785     return ret;
786 }
787 
CheckSubscriberRequiredPermission(const std::string & subscriberRequiredPermission,const CommonEventRecord & eventRecord,const EventSubscriberRecord & subscriberRecord)788 bool CommonEventControlManager::CheckSubscriberRequiredPermission(const std::string &subscriberRequiredPermission,
789     const CommonEventRecord &eventRecord, const EventSubscriberRecord &subscriberRecord)
790 {
791     bool ret = false;
792 
793     if (subscriberRequiredPermission.empty()) {
794         return true;
795     }
796 
797     ret = AccessTokenHelper::VerifyAccessToken(eventRecord.eventRecordInfo.callerToken, subscriberRequiredPermission);
798     if (!ret) {
799         EVENT_LOGW("No permission to send common event %{public}s "
800                     "from %{public}s (pid = %{public}d, uid = %{public}d), userId = %{public}d "
801                     "to %{public}s (pid = %{public}d, uid = %{public}d), userId = %{public}d "
802                     "due to subscriber requires the %{public}s permission.",
803             eventRecord.commonEventData->GetWant().GetAction().c_str(),
804             eventRecord.eventRecordInfo.bundleName.c_str(),
805             eventRecord.eventRecordInfo.pid,
806             eventRecord.eventRecordInfo.uid,
807             eventRecord.userId,
808             subscriberRecord.eventRecordInfo.bundleName.c_str(),
809             subscriberRecord.eventRecordInfo.pid,
810             subscriberRecord.eventRecordInfo.uid,
811             subscriberRecord.eventSubscribeInfo->GetUserId(),
812             subscriberRequiredPermission.c_str());
813     }
814 
815     return ret;
816 }
817 
CheckPublisherRequiredPermissions(const std::vector<std::string> & publisherRequiredPermissions,const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)818 bool CommonEventControlManager::CheckPublisherRequiredPermissions(
819     const std::vector<std::string> &publisherRequiredPermissions, const EventSubscriberRecord &subscriberRecord,
820     const CommonEventRecord &eventRecord)
821 {
822     bool ret = false;
823 
824     if (publisherRequiredPermissions.empty()) {
825         return true;
826     }
827 
828     for (auto publisherRequiredPermission : publisherRequiredPermissions) {
829         ret = AccessTokenHelper::VerifyAccessToken(
830             subscriberRecord.eventRecordInfo.callerToken, publisherRequiredPermission);
831         if (!ret) {
832             EVENT_LOGW("No permission to receive common event %{public}s "
833                         "to %{public}s (pid = %{public}d, uid = %{public}d), userId = %{public}d "
834                         "due to publisher %{public}s (pid = %{public}d, uid = %{public}d),"
835                         " userId = %{public}d requires the %{public}s permission.",
836                 eventRecord.commonEventData->GetWant().GetAction().c_str(),
837                 subscriberRecord.eventRecordInfo.bundleName.c_str(),
838                 subscriberRecord.eventRecordInfo.pid,
839                 subscriberRecord.eventRecordInfo.uid,
840                 subscriberRecord.eventSubscribeInfo->GetUserId(),
841                 eventRecord.eventRecordInfo.bundleName.c_str(),
842                 eventRecord.eventRecordInfo.pid,
843                 eventRecord.eventRecordInfo.uid,
844                 eventRecord.userId,
845                 publisherRequiredPermission.c_str());
846             break;
847         }
848     }
849 
850     return ret;
851 }
852 
GetUnorderedEventRecords(const std::string & event,const int32_t & userId,std::vector<std::shared_ptr<OrderedEventRecord>> & records)853 void CommonEventControlManager::GetUnorderedEventRecords(
854     const std::string &event, const int32_t &userId, std::vector<std::shared_ptr<OrderedEventRecord>> &records)
855 {
856     EVENT_LOGD("enter");
857     if (event.empty() && userId == ALL_USER) {
858         records = unorderedEventQueue_;
859     } else if (event.empty()) {
860         for (auto vec : unorderedEventQueue_) {
861             if (vec->userId == userId) {
862                 records.emplace_back(vec);
863             }
864         }
865     } else if (userId == ALL_USER) {
866         for (auto vec : unorderedEventQueue_) {
867             if (vec->commonEventData->GetWant().GetAction() == event) {
868                 records.emplace_back(vec);
869             }
870         }
871     } else {
872         for (auto vec : unorderedEventQueue_) {
873             if (vec->commonEventData->GetWant().GetAction() == event && vec->userId == userId) {
874                 records.emplace_back(vec);
875             }
876         }
877     }
878 }
879 
GetOrderedEventRecords(const std::string & event,const int32_t & userId,std::vector<std::shared_ptr<OrderedEventRecord>> & records)880 void CommonEventControlManager::GetOrderedEventRecords(
881     const std::string &event, const int32_t &userId, std::vector<std::shared_ptr<OrderedEventRecord>> &records)
882 {
883     EVENT_LOGD("enter");
884     if (event.empty() && userId == ALL_USER) {
885         records = orderedEventQueue_;
886     } else if (event.empty()) {
887         for (auto vec : orderedEventQueue_) {
888             if (vec->userId == userId) {
889                 records.emplace_back(vec);
890             }
891         }
892     } else if (userId == ALL_USER) {
893         for (auto vec : orderedEventQueue_) {
894             if (vec->commonEventData->GetWant().GetAction() == event) {
895                 records.emplace_back(vec);
896             }
897         }
898     } else {
899         for (auto vec : orderedEventQueue_) {
900             if (vec->commonEventData->GetWant().GetAction() == event && vec->userId == userId) {
901                 records.emplace_back(vec);
902             }
903         }
904     }
905 }
906 
DumpStateByCommonEventRecord(const std::shared_ptr<OrderedEventRecord> & record,std::string & dumpInfo)907 void CommonEventControlManager::DumpStateByCommonEventRecord(
908     const std::shared_ptr<OrderedEventRecord> &record, std::string &dumpInfo)
909 {
910     EVENT_LOGD("enter");
911 
912     char systime[LENGTH];
913     strftime(systime, sizeof(char) * LENGTH, "%Y%m%d %I:%M %p", &record->recordTime);
914 
915     std::string recordTime = "\tTime: " + std::string(systime) + "\n";
916     std::string pid = "\tPID: " + std::to_string(record->eventRecordInfo.pid) + "\n";
917     std::string uid = "\tUID: " + std::to_string(record->eventRecordInfo.uid) + "\n";
918     std::string userId;
919     switch (record->userId) {
920         case UNDEFINED_USER:
921             userId = "UNDEFINED_USER";
922             break;
923         case ALL_USER:
924             userId = "ALL_USER";
925             break;
926         default:
927             userId = std::to_string(record->userId);
928             break;
929     }
930     userId = "\tUSERID: " + userId + "\n";
931     std::string bundleName = "\tBundleName: " + record->eventRecordInfo.bundleName + "\n";
932 
933     std::string permission = "\tRequiredPermission: ";
934     std::string separator;
935     size_t permissionNum = 0;
936     for (auto permissionVec : record->publishInfo->GetSubscriberPermissions()) {
937         if (permissionNum == 0) {
938             separator = "";
939         } else {
940             separator = ", ";
941         }
942         permission = permission + separator + permissionVec;
943         permissionNum++;
944     }
945     permission = permission + "\n";
946 
947     std::string isSticky;
948     if (record->publishInfo->IsSticky()) {
949         isSticky = "\tIsSticky: true\n";
950     } else {
951         isSticky = "\tIsSticky: false\n";
952     }
953 
954     std::string isOrdered;
955     if (record->publishInfo->IsOrdered()) {
956         isOrdered = "\tIsOrdered: true\n";
957     } else {
958         isOrdered = "\tIsOrdered: false\n";
959     }
960     std::string isSystemApp = record->eventRecordInfo.isSystemApp ? "true" : "false";
961     isSystemApp = "\tIsSystemApp: " + isSystemApp + "\n";
962     std::string isSystemEvent = record->isSystemEvent ? "true" : "false";
963     isSystemEvent = "\tIsSystemEvent: " + isSystemEvent + "\n";
964 
965     std::string action = "\t\tAction: " + record->commonEventData->GetWant().GetAction() + "\n";
966 
967     std::string entities = "\t\tEntity: ";
968     size_t entityNum = 0;
969     for (auto entitiesVec : record->commonEventData->GetWant().GetEntities()) {
970         if (entityNum == 0) {
971             separator = "";
972         } else {
973             separator = ", ";
974         }
975         entities = entities + separator + entitiesVec;
976         entityNum++;
977     }
978     entities = entities + "\n";
979 
980     std::string scheme = "\t\tScheme: " + record->commonEventData->GetWant().GetScheme() + "\n";
981     std::string uri = "\t\tUri: " + record->commonEventData->GetWant().GetUriString() + "\n";
982     std::string flags = "\t\tFlags: " + std::to_string(record->commonEventData->GetWant().GetFlags()) + "\n";
983     std::string type = "\t\tType: " + record->commonEventData->GetWant().GetType() + "\n";
984     std::string bundle = "\t\tBundleName: " + record->commonEventData->GetWant().GetBundle() + "\n";
985     std::string ability = "\t\tAbilityName: " + record->commonEventData->GetWant().GetElement().GetAbilityName() + "\n";
986     std::string deviced = "\t\tDevicedID: " + record->commonEventData->GetWant().GetElement().GetDeviceID() + "\n";
987 
988     std::string want = "\tWant:\n" + action + entities + scheme + uri + flags + type + bundle + ability + deviced;
989     std::string code = "\tCode: " + std::to_string(record->commonEventData->GetCode()) + "\n";
990     std::string data = "\tData: " + record->commonEventData->GetData() + "\n";
991 
992     std::string lastSubscriber;
993     if (record->resultTo) {
994         lastSubscriber = "\tHasLastSubscriber: true\n";
995     } else {
996         lastSubscriber = "\tHasLastSubscriber: false\n";
997     }
998 
999     std::string state;
1000     switch (record->state) {
1001         case OrderedEventRecord::IDLE:
1002             state = "\tEventState: IDLE\n";
1003             break;
1004         case OrderedEventRecord::RECEIVING:
1005             state = "\tEventState: RECEIVING\n";
1006             break;
1007         case OrderedEventRecord::RECEIVED:
1008             state = "\tEventState: RECEIVED\n";
1009             break;
1010     }
1011 
1012     std::string dispatchTime = "\tDispatchTime: " + std::to_string(record->dispatchTime) + "\n";
1013     std::string receiverTime = "\tReceiverTime: " + std::to_string(record->receiverTime) + "\n";
1014     std::string resultAbort = record->resultAbort ? "true" : "false";
1015     resultAbort = "\tResultAbort: " + resultAbort + "\n";
1016 
1017     dumpInfo = recordTime + pid + uid + userId + bundleName + permission + isSticky + isOrdered + isSystemApp +
1018                isSystemEvent + want + code + data + lastSubscriber + state + receiverTime + dispatchTime + resultAbort;
1019 }
1020 
DumpStateBySubscriberRecord(const std::shared_ptr<OrderedEventRecord> & record,std::string & dumpInfo)1021 void CommonEventControlManager::DumpStateBySubscriberRecord(
1022     const std::shared_ptr<OrderedEventRecord> &record, std::string &dumpInfo)
1023 {
1024     EVENT_LOGD("enter");
1025 
1026     if (record->receivers.empty()) {
1027         dumpInfo = "\tSubscribers:\tNo information";
1028         return;
1029     }
1030 
1031     size_t num = 0;
1032     for (auto receiver : record->receivers) {
1033         num++;
1034 
1035         std::string title = std::to_string(num);
1036         if (num == 1) {
1037             title = "\tSubscribers:\tTotal " + std::to_string(record->receivers.size()) + " subscribers\n\tNO " +
1038                     title + "\n";
1039         } else {
1040             title = "\tNO " + title + "\n";
1041         }
1042 
1043         std::string dumpInfoBySubscriber;
1044         DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->DumpDetailed(
1045             title, receiver, "\t\t", dumpInfoBySubscriber);
1046 
1047         std::string deliveryState;
1048         switch (record->deliveryState[num - 1]) {
1049             case OrderedEventRecord::PENDING:
1050                 deliveryState = "\t\tEventState: PENDING\n";
1051                 break;
1052             case OrderedEventRecord::DELIVERED:
1053                 deliveryState = "\t\tEventState: DELIVERED\n";
1054                 break;
1055             case OrderedEventRecord::SKIPPED:
1056                 deliveryState = "\t\tEventState: SKIPPED\n";
1057                 break;
1058             case OrderedEventRecord::TIMEOUT:
1059                 deliveryState = "\t\tEventState: TIMEOUT\n";
1060                 break;
1061         }
1062         dumpInfo = dumpInfo + dumpInfoBySubscriber + deliveryState;
1063     }
1064 }
1065 
DumpState(const std::string & event,const int32_t & userId,std::vector<std::string> & state)1066 void CommonEventControlManager::DumpState(
1067     const std::string &event, const int32_t &userId, std::vector<std::string> &state)
1068 {
1069     EVENT_LOGD("enter");
1070 
1071     std::vector<std::shared_ptr<OrderedEventRecord>> records;
1072     std::vector<std::shared_ptr<OrderedEventRecord>> unorderedRecords;
1073     std::vector<std::shared_ptr<OrderedEventRecord>> orderedRecords;
1074     std::lock_guard<std::mutex> orderedLock(orderedMutex_);
1075     std::lock_guard<std::mutex> unorderedLock(unorderedMutex_);
1076     GetUnorderedEventRecords(event, userId, unorderedRecords);
1077     GetOrderedEventRecords(event, userId, orderedRecords);
1078     records.insert(records.end(), unorderedRecords.begin(), unorderedRecords.end());
1079     records.insert(records.end(), orderedRecords.begin(), orderedRecords.end());
1080 
1081     if (records.empty()) {
1082         state.emplace_back("Pending Events:\tNo information");
1083         return;
1084     }
1085 
1086     size_t num = 0;
1087     for (auto record : records) {
1088         num++;
1089 
1090         std::string no = std::to_string(num);
1091         if (num == 1) {
1092             no = "Pending Events:\tTotal " + std::to_string(records.size()) + " information\nNO " + no + "\n";
1093         } else {
1094             no = "NO " + no + "\n";
1095         }
1096         std::string commonEventRecord;
1097         DumpStateByCommonEventRecord(record, commonEventRecord);
1098         std::string subscriberRecord;
1099         DumpStateBySubscriberRecord(record, subscriberRecord);
1100         std::string stateInfo = no + commonEventRecord + subscriberRecord;
1101         state.emplace_back(stateInfo);
1102     }
1103 }
1104 
SendOrderedEventProcTimeoutHiSysEvent(const std::shared_ptr<EventSubscriberRecord> & subscriberRecord,const std::string & eventName)1105 void CommonEventControlManager::SendOrderedEventProcTimeoutHiSysEvent(
1106     const std::shared_ptr<EventSubscriberRecord> &subscriberRecord, const std::string &eventName)
1107 {
1108     if (subscriberRecord == nullptr) {
1109         return;
1110     }
1111 
1112     EventInfo eventInfo;
1113     if (subscriberRecord->eventSubscribeInfo != nullptr) {
1114         eventInfo.userId = subscriberRecord->eventSubscribeInfo->GetUserId();
1115     }
1116     eventInfo.subscriberName = subscriberRecord->eventRecordInfo.bundleName;
1117     eventInfo.pid = subscriberRecord->eventRecordInfo.pid;
1118     eventInfo.uid = static_cast<int32_t>(subscriberRecord->eventRecordInfo.uid);
1119     eventInfo.eventName = eventName;
1120     EventReport::SendHiSysEvent(ORDERED_EVENT_PROC_TIMEOUT, eventInfo);
1121 }
1122 }  // namespace EventFwk
1123 }  // namespace OHOS