• 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 
CommonEventControlManager()36 CommonEventControlManager::CommonEventControlManager()
37     : handler_(nullptr), handlerOrdered_(nullptr), pendingTimeoutMessage_(false), scheduled_(false)
38 {
39     EVENT_LOGD("enter");
40 }
41 
~CommonEventControlManager()42 CommonEventControlManager::~CommonEventControlManager()
43 {
44     EVENT_LOGD("enter");
45 }
46 
PublishCommonEvent(const CommonEventRecord & eventRecord,const sptr<IRemoteObject> & commonEventListener)47 bool CommonEventControlManager::PublishCommonEvent(
48     const CommonEventRecord &eventRecord, const sptr<IRemoteObject> &commonEventListener)
49 {
50     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
51     EVENT_LOGD("enter");
52 
53     bool ret = false;
54 
55     if (!eventRecord.publishInfo->IsOrdered()) {
56         ret = ProcessUnorderedEvent(eventRecord);
57     } else {
58         ret = ProcessOrderedEvent(eventRecord, commonEventListener);
59     }
60 
61     return ret;
62 }
63 
PublishStickyCommonEvent(const CommonEventRecord & eventRecord,const std::shared_ptr<EventSubscriberRecord> & subscriberRecord)64 bool CommonEventControlManager::PublishStickyCommonEvent(
65     const CommonEventRecord &eventRecord, const std::shared_ptr<EventSubscriberRecord> &subscriberRecord)
66 {
67     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
68     EVENT_LOGD("enter");
69 
70     if (!subscriberRecord) {
71         EVENT_LOGE("subscriberRecord is null");
72         return false;
73     }
74     return ProcessUnorderedEvent(eventRecord, subscriberRecord);
75 }
76 
PublishFreezeCommonEvent(const uid_t & uid)77 bool CommonEventControlManager::PublishFreezeCommonEvent(const uid_t &uid)
78 {
79     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
80     EVENT_LOGD("enter");
81 
82     if (!GetUnorderedEventHandler()) {
83         EVENT_LOGE("failed to get eventhandler");
84         return false;
85     }
86     PublishFrozenEventsInner(DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->GetFrozenEvents(uid));
87     return true;
88 }
89 
PublishAllFreezeCommonEvents()90 bool CommonEventControlManager::PublishAllFreezeCommonEvents()
91 {
92     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
93     EVENT_LOGD("enter");
94 
95     if (!GetUnorderedEventHandler()) {
96         EVENT_LOGE("failed to get eventhandler");
97         return false;
98     }
99 
100     std::map<uid_t, FrozenRecords> frozenEventRecords =
101         DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->GetAllFrozenEvents();
102     for (auto record : frozenEventRecords) {
103         PublishFrozenEventsInner(record.second);
104     }
105     return true;
106 }
107 
PublishFrozenEventsInner(const FrozenRecords & frozenRecords)108 void CommonEventControlManager::PublishFrozenEventsInner(const FrozenRecords &frozenRecords)
109 {
110     for (auto record : frozenRecords) {
111         for (auto vec : record.second) {
112             if (!vec) {
113                 EVENT_LOGW("failed to find record");
114                 continue;
115             }
116 
117             EventSubscriberRecord subscriberRecord = record.first;
118             CommonEventRecord eventRecord = *vec;
119             std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
120             auto innerCallback = [weak, subscriberRecord, eventRecord]() {
121                 auto control = weak.lock();
122                 if (control == nullptr) {
123                     EVENT_LOGE("CommonEventControlManager is null");
124                     return;
125                 }
126                 control->NotifyFreezeEvents(subscriberRecord, eventRecord);
127             };
128             unorderedImmediateQueue_->submit(innerCallback);
129         }
130     }
131 }
132 
NotifyFreezeEvents(const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)133 bool CommonEventControlManager::NotifyFreezeEvents(
134     const EventSubscriberRecord &subscriberRecord, const CommonEventRecord &eventRecord)
135 {
136     EVENT_LOGD("enter");
137 
138     sptr<IEventReceive> commonEventListenerProxy = iface_cast<IEventReceive>(subscriberRecord.commonEventListener);
139     if (!commonEventListenerProxy) {
140         EVENT_LOGE("Fail to get IEventReceive proxy");
141         return false;
142     }
143 
144     int8_t ret = CheckPermission(subscriberRecord, eventRecord);
145     if (ret != OrderedEventRecord::DELIVERED) {
146         EVENT_LOGE("check permission is failed");
147         return false;
148     }
149     if (eventRecord.commonEventData == nullptr) {
150         EVENT_LOGE("commonEventData == nullptr");
151         return false;
152     }
153     EVENT_LOGD("Send common event %{public}s to subscriber %{public}s (pid = %{public}d, uid = %{public}d) "
154                 "when unfreezed",
155         eventRecord.commonEventData->GetWant().GetAction().c_str(),
156         subscriberRecord.eventRecordInfo.bundleName.c_str(),
157         subscriberRecord.eventRecordInfo.pid,
158         subscriberRecord.eventRecordInfo.uid);
159     commonEventListenerProxy->NotifyEvent(*(eventRecord.commonEventData),
160         false, eventRecord.publishInfo->IsSticky());
161     AccessTokenHelper::RecordSensitivePermissionUsage(subscriberRecord.eventRecordInfo.callerToken,
162         eventRecord.commonEventData->GetWant().GetAction());
163     return true;
164 }
165 
GetUnorderedEventHandler()166 bool CommonEventControlManager::GetUnorderedEventHandler()
167 {
168     if (!unorderedQueue_) {
169         unorderedQueue_ = std::make_shared<ffrt::queue>("unordered_common_event");
170     }
171 
172     if (!unorderedImmediateQueue_) {
173         unorderedImmediateQueue_ = std::make_shared<ffrt::queue>("unordered_immediate_common_event",
174             ffrt::queue_attr().qos(ffrt::qos_utility));
175     }
176 
177     return true;
178 }
179 
NotifyUnorderedEvent(std::shared_ptr<OrderedEventRecord> & eventRecord)180 bool CommonEventControlManager::NotifyUnorderedEvent(std::shared_ptr<OrderedEventRecord> &eventRecord)
181 {
182     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
183     EVENT_LOGD("enter");
184     if (!eventRecord) {
185         EVENT_LOGD("Invalid event record.");
186         return false;
187     }
188     std::lock_guard<std::mutex> lock(unorderedMutex_);
189     EVENT_LOGD("event = %{public}s, receivers size = %{public}zu",
190         eventRecord->commonEventData->GetWant().GetAction().c_str(), eventRecord->receivers.size());
191     for (auto vec : eventRecord->receivers) {
192         if (vec == nullptr) {
193             EVENT_LOGE("invalid vec");
194             continue;
195         }
196         size_t index = eventRecord->nextReceiver++;
197         eventRecord->curReceiver = vec->commonEventListener;
198         if (vec->isFreeze) {
199             eventRecord->deliveryState[index] = OrderedEventRecord::SKIPPED;
200             DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->InsertFrozenEvents(vec, *eventRecord);
201         } else {
202             sptr<IEventReceive> commonEventListenerProxy = iface_cast<IEventReceive>(vec->commonEventListener);
203             if (!commonEventListenerProxy) {
204                 eventRecord->deliveryState[index] = OrderedEventRecord::SKIPPED;
205                 EVENT_LOGE("Failed to get IEventReceive proxy");
206                 continue;
207             }
208             int8_t ret = CheckPermission(*vec, *eventRecord);
209             eventRecord->deliveryState[index] = ret;
210             if (ret == OrderedEventRecord::DELIVERED) {
211                 eventRecord->state = OrderedEventRecord::RECEIVING;
212                 commonEventListenerProxy->NotifyEvent(
213                     *(eventRecord->commonEventData), false, eventRecord->publishInfo->IsSticky());
214                 eventRecord->state = OrderedEventRecord::RECEIVED;
215                 AccessTokenHelper::RecordSensitivePermissionUsage(vec->eventRecordInfo.callerToken,
216                     eventRecord->commonEventData->GetWant().GetAction());
217             }
218         }
219     }
220 
221     EnqueueHistoryEventRecord(eventRecord, false);
222 
223     auto it = std::find(unorderedEventQueue_.begin(), unorderedEventQueue_.end(), eventRecord);
224     if (it != unorderedEventQueue_.end()) {
225         unorderedEventQueue_.erase(it);
226     }
227     return true;
228 }
229 
ProcessUnorderedEvent(const CommonEventRecord & eventRecord,const std::shared_ptr<EventSubscriberRecord> & subscriberRecord)230 bool CommonEventControlManager::ProcessUnorderedEvent(
231     const CommonEventRecord &eventRecord, const std::shared_ptr<EventSubscriberRecord> &subscriberRecord)
232 {
233     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
234     EVENT_LOGD("enter");
235 
236     bool ret = false;
237 
238     if (!GetUnorderedEventHandler()) {
239         EVENT_LOGE("failed to get eventhandler");
240         return ret;
241     }
242 
243     std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
244     if (eventRecordPtr == nullptr) {
245         EVENT_LOGE("eventRecordPtr is null");
246         return ret;
247     }
248 
249     std::shared_ptr<CommonEventSubscriberManager> spinstance =
250         DelayedSingleton<CommonEventSubscriberManager>::GetInstance();
251 
252     eventRecordPtr->FillCommonEventRecord(eventRecord);
253     if (subscriberRecord) {
254         eventRecordPtr->receivers.emplace_back(subscriberRecord);
255     } else {
256         eventRecordPtr->receivers = spinstance->GetSubscriberRecords(eventRecord);
257     }
258 
259     for (auto vec : eventRecordPtr->receivers) {
260         eventRecordPtr->deliveryState.emplace_back(OrderedEventRecord::PENDING);
261     }
262 
263     EnqueueUnorderedRecord(eventRecordPtr);
264 
265     std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
266     auto innerCallback = [weak, eventRecordPtr]() {
267         auto manager = weak.lock();
268         if (manager == nullptr) {
269             EVENT_LOGE("CommonEventControlManager is null");
270             return;
271         }
272         std::shared_ptr<OrderedEventRecord> ordered = eventRecordPtr;
273         manager->NotifyUnorderedEvent(ordered);
274     };
275 
276     if (eventRecord.isSystemEvent) {
277         unorderedImmediateQueue_->submit(innerCallback);
278     } else {
279         unorderedQueue_->submit(innerCallback);
280     }
281 
282     return ret;
283 }
284 
GetMatchingOrderedReceiver(const sptr<IRemoteObject> & proxy)285 std::shared_ptr<OrderedEventRecord> CommonEventControlManager::GetMatchingOrderedReceiver(
286     const sptr<IRemoteObject> &proxy)
287 {
288     EVENT_LOGD("enter");
289 
290     std::lock_guard<std::mutex> lock(orderedMutex_);
291 
292     if (!orderedEventQueue_.empty()) {
293         std::shared_ptr<OrderedEventRecord> firstRecord = orderedEventQueue_.front();
294         if ((firstRecord != nullptr) && (firstRecord->curReceiver == proxy)) {
295             return firstRecord;
296         }
297     }
298 
299     return nullptr;
300 }
301 
GetOrderedEventHandler()302 bool CommonEventControlManager::GetOrderedEventHandler()
303 {
304     if (!orderedQueue_) {
305         orderedQueue_ = std::make_shared<ffrt::queue>("ordered_common_event");
306     }
307     return true;
308 }
309 
ProcessOrderedEvent(const CommonEventRecord & eventRecord,const sptr<IRemoteObject> & commonEventListener)310 bool CommonEventControlManager::ProcessOrderedEvent(
311     const CommonEventRecord &eventRecord, const sptr<IRemoteObject> &commonEventListener)
312 {
313     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
314     EVENT_LOGD("enter");
315 
316     bool ret = false;
317 
318     if (!GetOrderedEventHandler()) {
319         EVENT_LOGE("failed to get eventhandler");
320         return ret;
321     }
322 
323     std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
324     if (eventRecordPtr == nullptr) {
325         EVENT_LOGE("eventRecordPtr is null");
326         return ret;
327     }
328 
329     std::shared_ptr<CommonEventSubscriberManager> spinstance =
330         DelayedSingleton<CommonEventSubscriberManager>::GetInstance();
331 
332     eventRecordPtr->FillCommonEventRecord(eventRecord);
333     eventRecordPtr->resultTo = commonEventListener;
334     eventRecordPtr->state = OrderedEventRecord::IDLE;
335     eventRecordPtr->nextReceiver = 0;
336     eventRecordPtr->receivers = spinstance->GetSubscriberRecords(eventRecord);
337     for (auto vec : eventRecordPtr->receivers) {
338         eventRecordPtr->deliveryState.emplace_back(OrderedEventRecord::PENDING);
339     }
340 
341     EnqueueOrderedRecord(eventRecordPtr);
342 
343     ret = ScheduleOrderedCommonEvent();
344 
345     return ret;
346 }
347 
EnqueueUnorderedRecord(const std::shared_ptr<OrderedEventRecord> & eventRecordPtr)348 bool CommonEventControlManager::EnqueueUnorderedRecord(const std::shared_ptr<OrderedEventRecord> &eventRecordPtr)
349 {
350     if (eventRecordPtr == nullptr) {
351         EVENT_LOGE("eventRecordPtr is null");
352         return false;
353     }
354 
355     std::lock_guard<std::mutex> lock(unorderedMutex_);
356 
357     unorderedEventQueue_.emplace_back(eventRecordPtr);
358 
359     return true;
360 }
361 
EnqueueOrderedRecord(const std::shared_ptr<OrderedEventRecord> & eventRecordPtr)362 bool CommonEventControlManager::EnqueueOrderedRecord(const std::shared_ptr<OrderedEventRecord> &eventRecordPtr)
363 {
364     if (eventRecordPtr == nullptr) {
365         EVENT_LOGE("eventRecordPtr is null");
366         return false;
367     }
368 
369     std::lock_guard<std::mutex> lock(orderedMutex_);
370 
371     orderedEventQueue_.emplace_back(eventRecordPtr);
372 
373     return true;
374 }
375 
EnqueueHistoryEventRecord(const std::shared_ptr<OrderedEventRecord> & eventRecordPtr,bool hasLastSubscribe)376 void CommonEventControlManager::EnqueueHistoryEventRecord(
377     const std::shared_ptr<OrderedEventRecord> &eventRecordPtr, bool hasLastSubscribe)
378 {
379     EVENT_LOGD("enter");
380 
381     if (eventRecordPtr == nullptr) {
382         EVENT_LOGE("eventRecordPtr is nullptr");
383         return;
384     }
385 
386     HistoryEventRecord record;
387     record.want = eventRecordPtr->commonEventData->GetWant();
388     record.code = eventRecordPtr->commonEventData->GetCode();
389     record.data = eventRecordPtr->commonEventData->GetData();
390 
391     record.sticky = eventRecordPtr->publishInfo->IsSticky();
392     record.ordered = eventRecordPtr->publishInfo->IsOrdered();
393     record.subscriberPermissions = eventRecordPtr->publishInfo->GetSubscriberPermissions();
394 
395     record.recordTime = eventRecordPtr->recordTime;
396     record.pid = eventRecordPtr->eventRecordInfo.pid;
397     record.uid = eventRecordPtr->eventRecordInfo.uid;
398     record.userId = eventRecordPtr->userId;
399     record.bundleName = eventRecordPtr->eventRecordInfo.bundleName;
400     record.isSystemApp = eventRecordPtr->eventRecordInfo.isSystemApp;
401     record.isSystemEvent = eventRecordPtr->isSystemEvent;
402 
403     for (auto vec : eventRecordPtr->receivers) {
404         if (vec == nullptr) {
405             continue;
406         }
407         HistorySubscriberRecord receiver;
408         receiver.recordTime = vec->recordTime;
409         receiver.bundleName = vec->eventRecordInfo.bundleName;
410         receiver.priority = vec->eventSubscribeInfo->GetPriority();
411         receiver.userId = vec->eventSubscribeInfo->GetUserId();
412         receiver.permission = vec->eventSubscribeInfo->GetPermission();
413         receiver.deviceId = vec->eventSubscribeInfo->GetDeviceId();
414         receiver.isFreeze = vec->isFreeze;
415         receiver.freezeTime = vec->freezeTime;
416         record.receivers.emplace_back(receiver);
417     }
418 
419     record.hasLastSubscribe = hasLastSubscribe;
420     record.deliveryState = eventRecordPtr->deliveryState;
421     record.dispatchTime = eventRecordPtr->dispatchTime;
422     record.receiverTime = eventRecordPtr->receiverTime;
423     record.state = eventRecordPtr->state;
424     record.resultAbort = eventRecordPtr->resultAbort;
425 
426     std::lock_guard<std::mutex> lock(historyMutex_);
427     if (historyEventRecords_.size() == HISTORY_MAX_SIZE) {
428         historyEventRecords_.pop_front();
429     }
430     historyEventRecords_.push_back(record);
431 }
432 
ScheduleOrderedCommonEvent()433 bool CommonEventControlManager::ScheduleOrderedCommonEvent()
434 {
435     EVENT_LOGD("enter");
436 
437     if (scheduled_) {
438         return true;
439     }
440 
441     scheduled_ = true;
442 
443     std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
444     orderedQueue_->submit([weak]() {
445         auto manager = weak.lock();
446         if (manager == nullptr) {
447             EVENT_LOGE("CommonEventControlManager is null");
448             return;
449         }
450         manager->ProcessNextOrderedEvent(true);
451     });
452     return true;
453 }
454 
NotifyOrderedEvent(std::shared_ptr<OrderedEventRecord> & eventRecordPtr,size_t index)455 bool CommonEventControlManager::NotifyOrderedEvent(std::shared_ptr<OrderedEventRecord> &eventRecordPtr, size_t index)
456 {
457     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
458     EVENT_LOGD("enter with index %{public}zu", index);
459     if (eventRecordPtr == nullptr) {
460         EVENT_LOGE("eventRecordPtr = nullptr");
461         return false;
462     }
463     size_t receiverNum = eventRecordPtr->receivers.size();
464     if ((index < 0) || (index >= receiverNum)) {
465         EVENT_LOGE("Invalid index (= %{public}zu)", index);
466         return false;
467     }
468     int8_t ret = CheckPermission(*(eventRecordPtr->receivers[index]), *eventRecordPtr);
469     if (ret == OrderedEventRecord::SKIPPED) {
470         eventRecordPtr->deliveryState[index] = ret;
471         return true;
472     }
473     if (ret == OrderedEventRecord::DELIVERED) {
474         if (eventRecordPtr->receivers[index]->isFreeze) {
475             EVENT_LOGD("vec isFreeze: %{public}d", eventRecordPtr->receivers[index]->isFreeze);
476             DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->InsertFrozenEvents(
477                 eventRecordPtr->receivers[index], *eventRecordPtr);
478             eventRecordPtr->deliveryState[index] = OrderedEventRecord::SKIPPED;
479             eventRecordPtr->curReceiver = nullptr;
480             return true;
481         }
482         eventRecordPtr->deliveryState[index] = ret;
483         eventRecordPtr->curReceiver = eventRecordPtr->receivers[index]->commonEventListener;
484         eventRecordPtr->state = OrderedEventRecord::RECEIVING;
485         sptr<IEventReceive> receiver = iface_cast<IEventReceive>(eventRecordPtr->curReceiver);
486         if (!receiver) {
487             EVENT_LOGE("Failed to get IEventReceive proxy");
488             eventRecordPtr->curReceiver = nullptr;
489             return false;
490         }
491         eventRecordPtr->state = OrderedEventRecord::RECEIVED;
492         EVENT_LOGD("NotifyOrderedEvent event = %{public}s",
493             eventRecordPtr->commonEventData->GetWant().GetAction().c_str());
494         receiver->NotifyEvent(*(eventRecordPtr->commonEventData), true, eventRecordPtr->publishInfo->IsSticky());
495         AccessTokenHelper::RecordSensitivePermissionUsage(
496             eventRecordPtr->receivers[index]->eventRecordInfo.callerToken,
497             eventRecordPtr->commonEventData->GetWant().GetAction());
498     }
499     return true;
500 }
501 
ProcessNextOrderedEvent(bool isSendMsg)502 void CommonEventControlManager::ProcessNextOrderedEvent(bool isSendMsg)
503 {
504     HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
505     EVENT_LOGD("enter");
506 
507     if (isSendMsg) {
508         scheduled_ = false;
509     }
510 
511     std::shared_ptr<OrderedEventRecord> sp = nullptr;
512 
513     std::lock_guard<std::mutex> lock(orderedMutex_);
514 
515     do {
516         if (orderedEventQueue_.empty()) {
517             EVENT_LOGD("orderedEventQueue_ is empty");
518             return;
519         }
520 
521         sp = orderedEventQueue_.front();
522         bool forceReceive = false;
523         size_t numReceivers = sp->receivers.size();
524         uint64_t nowSysTime = static_cast<uint64_t>(SystemTime::GetNowSysTime());
525 
526         if (sp->dispatchTime > 0) {
527             if ((numReceivers > 0) && (nowSysTime > static_cast<uint64_t>(sp->dispatchTime) +
528                 (DOUBLE * TIMEOUT * numReceivers))) {
529                 CurrentOrderedEventTimeout(false);
530                 forceReceive = true;
531                 sp->state = OrderedEventRecord::IDLE;
532             }
533         }
534 
535         if (sp->state != OrderedEventRecord::IDLE) {
536             return;
537         }
538 
539         if ((sp->receivers.empty()) || (sp->nextReceiver >= numReceivers) || sp->resultAbort || forceReceive) {
540             // No more receivers for this ordered common event, then process the final result receiver
541             bool hasLastSubscribe = (sp->resultTo != nullptr) ? true : false;
542             if (sp->resultTo != nullptr) {
543                 EVENT_LOGD("Process the final subscriber");
544                 sptr<IEventReceive> receiver = iface_cast<IEventReceive>(sp->resultTo);
545                 if (!receiver) {
546                     EVENT_LOGE("Failed to get IEventReceive proxy");
547                     return;
548                 }
549                 receiver->NotifyEvent(*(sp->commonEventData), true, sp->publishInfo->IsSticky());
550                 sp->resultTo = nullptr;
551             }
552 
553             CancelTimeout();
554 
555             EnqueueHistoryEventRecord(sp, hasLastSubscribe);
556 
557             orderedEventQueue_.erase(orderedEventQueue_.begin());
558 
559             sp = nullptr;
560         }
561     } while (sp == nullptr);
562 
563     size_t recIdx = sp->nextReceiver++;
564     SetTime(recIdx, sp, pendingTimeoutMessage_);
565 
566     NotifyOrderedEvent(sp, recIdx);
567     if (sp->curReceiver == nullptr) {
568         sp->state = OrderedEventRecord::IDLE;
569         ScheduleOrderedCommonEvent();
570     }
571 }
572 
SetTime(size_t recIdx,std::shared_ptr<OrderedEventRecord> & sp,bool timeoutMessage)573 void CommonEventControlManager::SetTime(size_t recIdx, std::shared_ptr<OrderedEventRecord> &sp, bool timeoutMessage)
574 {
575     EVENT_LOGD("enter");
576 
577     sp->receiverTime = SystemTime::GetNowSysTime();
578 
579     if (recIdx == 0) {
580         sp->dispatchTime = sp->receiverTime;
581     }
582 
583     if (!timeoutMessage) {
584         SetTimeout();
585     }
586 }
587 
SetTimeout()588 bool CommonEventControlManager::SetTimeout()
589 {
590     EVENT_LOGD("enter");
591 
592     bool ret = true;
593 
594     if (!pendingTimeoutMessage_) {
595         pendingTimeoutMessage_ = true;
596         std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
597         orderedHandler = orderedQueue_->submit_h([weak]() {
598             auto manager = weak.lock();
599             if (manager == nullptr) {
600                 EVENT_LOGE("CommonEventControlManager is null");
601                 return;
602             }
603             manager->CurrentOrderedEventTimeout(true);
604         }, ffrt::task_attr().delay(TIMEOUT * 1000));
605     }
606 
607     return ret;
608 }
609 
CancelTimeout()610 bool CommonEventControlManager::CancelTimeout()
611 {
612     EVENT_LOGD("enter");
613 
614     if (pendingTimeoutMessage_) {
615         pendingTimeoutMessage_ = false;
616         orderedQueue_->cancel(orderedHandler);
617     }
618 
619     return true;
620 }
621 
CurrentOrderedEventTimeout(bool isFromMsg)622 void CommonEventControlManager::CurrentOrderedEventTimeout(bool isFromMsg)
623 {
624     EVENT_LOGD("enter");
625 
626     if (isFromMsg) {
627         pendingTimeoutMessage_ = false;
628     }
629 
630     if (orderedEventQueue_.empty()) {
631         EVENT_LOGE("empty orderedEventQueue_");
632         return;
633     }
634 
635     int64_t nowSysTime = SystemTime::GetNowSysTime();
636     std::shared_ptr<OrderedEventRecord> sp = orderedEventQueue_.front();
637 
638     if (isFromMsg) {
639         int64_t timeoutTime = sp->receiverTime + TIMEOUT;
640         if (timeoutTime > nowSysTime) {
641             SetTimeout();
642             return;
643         }
644     }
645 
646     // The processing of current receiver has timeout
647     sp->receiverTime = nowSysTime;
648 
649     if (sp->nextReceiver > 0) {
650         std::shared_ptr<EventSubscriberRecord> subscriberRecord = sp->receivers[sp->nextReceiver - 1];
651         EVENT_LOGW("Timeout: When %{public}s (pid = %{public}d, uid = %{public}d) process common event %{public}s",
652             subscriberRecord->eventRecordInfo.bundleName.c_str(),
653             subscriberRecord->eventRecordInfo.pid,
654             subscriberRecord->eventRecordInfo.uid,
655             sp->commonEventData->GetWant().GetAction().c_str());
656         SendOrderedEventProcTimeoutHiSysEvent(subscriberRecord, sp->commonEventData->GetWant().GetAction());
657 
658         sp->deliveryState[sp->nextReceiver - 1] = OrderedEventRecord::TIMEOUT;
659     }
660 
661     // Forced to finish the current receiver to process the next receiver
662     int32_t code = sp->commonEventData->GetCode();
663     const std::string &strRef = sp->commonEventData->GetData();
664     bool abort = sp->resultAbort;
665     FinishReceiver(sp, code, strRef, abort);
666 
667     ScheduleOrderedCommonEvent();
668 
669     return;
670 }
671 
FinishReceiver(std::shared_ptr<OrderedEventRecord> recordPtr,const int32_t & code,const std::string & receiverData,const bool & abortEvent)672 bool CommonEventControlManager::FinishReceiver(std::shared_ptr<OrderedEventRecord> recordPtr, const int32_t &code,
673     const std::string &receiverData, const bool &abortEvent)
674 {
675     EVENT_LOGD("enter");
676 
677     if (recordPtr == nullptr) {
678         EVENT_LOGE("recordPtr is null");
679         return false;
680     }
681 
682     EVENT_LOGD("enter recordPtr->state=%{public}d", recordPtr->state);
683 
684     int8_t state = recordPtr->state;
685     recordPtr->state = OrderedEventRecord::IDLE;
686     recordPtr->curReceiver = nullptr;
687     recordPtr->commonEventData->SetCode(code);
688     recordPtr->commonEventData->SetData(receiverData);
689     recordPtr->resultAbort = abortEvent;
690 
691     return state == OrderedEventRecord::RECEIVED;
692 }
693 
FinishReceiverAction(std::shared_ptr<OrderedEventRecord> recordPtr,const int32_t & code,const std::string & receiverData,const bool & abortEvent)694 bool CommonEventControlManager::FinishReceiverAction(std::shared_ptr<OrderedEventRecord> recordPtr, const int32_t &code,
695     const std::string &receiverData, const bool &abortEvent)
696 {
697     EVENT_LOGD("enter");
698 
699     if (recordPtr == nullptr) {
700         EVENT_LOGE("recordPtr is nullptr");
701         return false;
702     }
703 
704     bool doNext = false;
705     doNext = FinishReceiver(recordPtr, code, receiverData, abortEvent);
706     if (doNext) {
707         ProcessNextOrderedEvent(false);
708     }
709 
710     return true;
711 }
712 
CheckPermission(const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)713 int8_t CommonEventControlManager::CheckPermission(
714     const EventSubscriberRecord &subscriberRecord, const CommonEventRecord &eventRecord)
715 {
716     EVENT_LOGD("enter");
717 
718     bool ret = false;
719     ret = CheckSubscriberPermission(subscriberRecord, eventRecord);
720     if (!ret) {
721         return OrderedEventRecord::SKIPPED;
722     }
723 
724     std::string subscriberRequiredPermission = subscriberRecord.eventSubscribeInfo->GetPermission();
725     ret = CheckSubscriberRequiredPermission(subscriberRequiredPermission, eventRecord, subscriberRecord);
726     if (!ret) {
727         return OrderedEventRecord::SKIPPED;
728     }
729 
730     std::vector<std::string> publisherRequiredPermissions = eventRecord.publishInfo->GetSubscriberPermissions();
731     ret = CheckPublisherRequiredPermissions(publisherRequiredPermissions, subscriberRecord, eventRecord);
732     if (!ret) {
733         return OrderedEventRecord::SKIPPED;
734     }
735 
736     return OrderedEventRecord::DELIVERED;
737 }
738 
CheckSubscriberPermission(const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)739 bool CommonEventControlManager::CheckSubscriberPermission(
740     const EventSubscriberRecord &subscriberRecord, const CommonEventRecord &eventRecord)
741 {
742     EVENT_LOGD("enter");
743     bool ret = false;
744     std::string lackPermission {};
745     std::string event = eventRecord.commonEventData->GetWant().GetAction();
746     bool isSystemAPIEvent = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->IsSystemAPIEvent(event);
747     if (isSystemAPIEvent && !(subscriberRecord.eventRecordInfo.isSubsystem
748         || subscriberRecord.eventRecordInfo.isSystemApp)) {
749         EVENT_LOGW("Invalid permission for system api event.");
750         return false;
751     }
752     Permission permission = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event);
753     if (permission.names.empty()) {
754         return true;
755     }
756 
757     if (!subscriberRecord.eventRecordInfo.isProxy && (subscriberRecord.eventRecordInfo.isSubsystem
758         || subscriberRecord.eventRecordInfo.isSystemApp)) {
759         return true;
760     }
761 
762     if (permission.names.size() == 1) {
763         ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, permission.names[0]);
764         lackPermission = permission.names[0];
765     } else if (permission.state == PermissionState::AND) {
766         for (auto vec : permission.names) {
767             ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, vec);
768             if (!ret) {
769                 lackPermission = vec;
770                 break;
771             }
772         }
773     } else if (permission.state == PermissionState::OR) {
774         for (auto vec : permission.names) {
775             ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, vec);
776             lackPermission += vec + CONNECTOR;
777             if (ret) {
778                 break;
779             }
780         }
781         lackPermission = lackPermission.substr(0, lackPermission.length() - CONNECTOR.length());
782     } else {
783         EVENT_LOGW("Invalid Permission.");
784         return false;
785     }
786     if (!ret) {
787         EVENT_LOGW("No permission to receive common event %{public}s, "
788                     "due to subscriber %{public}s (pid = %{public}d, uid = %{public}d) lacks "
789                     "the %{public}s permission.",
790             event.c_str(), subscriberRecord.eventRecordInfo.bundleName.c_str(),
791             subscriberRecord.eventRecordInfo.pid, subscriberRecord.eventRecordInfo.uid, lackPermission.c_str());
792     }
793 
794     return ret;
795 }
796 
CheckSubscriberRequiredPermission(const std::string & subscriberRequiredPermission,const CommonEventRecord & eventRecord,const EventSubscriberRecord & subscriberRecord)797 bool CommonEventControlManager::CheckSubscriberRequiredPermission(const std::string &subscriberRequiredPermission,
798     const CommonEventRecord &eventRecord, const EventSubscriberRecord &subscriberRecord)
799 {
800     bool ret = false;
801 
802     if (subscriberRequiredPermission.empty() || eventRecord.eventRecordInfo.isSubsystem) {
803         return true;
804     }
805 
806     ret = AccessTokenHelper::VerifyAccessToken(eventRecord.eventRecordInfo.callerToken, subscriberRequiredPermission);
807     if (!ret) {
808         EVENT_LOGW("No permission to send common event %{public}s "
809                     "from %{public}s (pid = %{public}d, uid = %{public}d), userId = %{public}d "
810                     "to %{public}s (pid = %{public}d, uid = %{public}d), userId = %{public}d "
811                     "due to registered subscriber requires the %{public}s permission.",
812             eventRecord.commonEventData->GetWant().GetAction().c_str(),
813             eventRecord.eventRecordInfo.bundleName.c_str(),
814             eventRecord.eventRecordInfo.pid,
815             eventRecord.eventRecordInfo.uid,
816             eventRecord.userId,
817             subscriberRecord.eventRecordInfo.bundleName.c_str(),
818             subscriberRecord.eventRecordInfo.pid,
819             subscriberRecord.eventRecordInfo.uid,
820             subscriberRecord.eventSubscribeInfo->GetUserId(),
821             subscriberRequiredPermission.c_str());
822     }
823 
824     return ret;
825 }
826 
CheckPublisherRequiredPermissions(const std::vector<std::string> & publisherRequiredPermissions,const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)827 bool CommonEventControlManager::CheckPublisherRequiredPermissions(
828     const std::vector<std::string> &publisherRequiredPermissions, const EventSubscriberRecord &subscriberRecord,
829     const CommonEventRecord &eventRecord)
830 {
831     bool ret = false;
832 
833     if (publisherRequiredPermissions.empty() || subscriberRecord.eventRecordInfo.isSubsystem) {
834         return true;
835     }
836 
837     for (auto publisherRequiredPermission : publisherRequiredPermissions) {
838         ret = AccessTokenHelper::VerifyAccessToken(
839             subscriberRecord.eventRecordInfo.callerToken, publisherRequiredPermission);
840         if (!ret) {
841             EVENT_LOGW("No permission to receive common event %{public}s "
842                         "to %{public}s (pid = %{public}d, uid = %{public}d), userId = %{public}d "
843                         "due to publisher %{public}s (pid = %{public}d, uid = %{public}d),"
844                         " userId = %{public}d requires the %{public}s permission.",
845                 eventRecord.commonEventData->GetWant().GetAction().c_str(),
846                 subscriberRecord.eventRecordInfo.bundleName.c_str(),
847                 subscriberRecord.eventRecordInfo.pid,
848                 subscriberRecord.eventRecordInfo.uid,
849                 subscriberRecord.eventSubscribeInfo->GetUserId(),
850                 eventRecord.eventRecordInfo.bundleName.c_str(),
851                 eventRecord.eventRecordInfo.pid,
852                 eventRecord.eventRecordInfo.uid,
853                 eventRecord.userId,
854                 publisherRequiredPermission.c_str());
855             break;
856         }
857     }
858 
859     return ret;
860 }
861 
GetUnorderedEventRecords(const std::string & event,const int32_t & userId,std::vector<std::shared_ptr<OrderedEventRecord>> & records)862 void CommonEventControlManager::GetUnorderedEventRecords(
863     const std::string &event, const int32_t &userId, std::vector<std::shared_ptr<OrderedEventRecord>> &records)
864 {
865     EVENT_LOGD("enter");
866     if (event.empty() && userId == ALL_USER) {
867         records = unorderedEventQueue_;
868     } else if (event.empty()) {
869         for (auto vec : unorderedEventQueue_) {
870             if (vec->userId == userId) {
871                 records.emplace_back(vec);
872             }
873         }
874     } else if (userId == ALL_USER) {
875         for (auto vec : unorderedEventQueue_) {
876             if (vec->commonEventData->GetWant().GetAction() == event) {
877                 records.emplace_back(vec);
878             }
879         }
880     } else {
881         for (auto vec : unorderedEventQueue_) {
882             if (vec->commonEventData->GetWant().GetAction() == event && vec->userId == userId) {
883                 records.emplace_back(vec);
884             }
885         }
886     }
887 }
888 
GetOrderedEventRecords(const std::string & event,const int32_t & userId,std::vector<std::shared_ptr<OrderedEventRecord>> & records)889 void CommonEventControlManager::GetOrderedEventRecords(
890     const std::string &event, const int32_t &userId, std::vector<std::shared_ptr<OrderedEventRecord>> &records)
891 {
892     EVENT_LOGD("enter");
893     if (event.empty() && userId == ALL_USER) {
894         records = orderedEventQueue_;
895     } else if (event.empty()) {
896         for (auto vec : orderedEventQueue_) {
897             if (vec->userId == userId) {
898                 records.emplace_back(vec);
899             }
900         }
901     } else if (userId == ALL_USER) {
902         for (auto vec : orderedEventQueue_) {
903             if (vec->commonEventData->GetWant().GetAction() == event) {
904                 records.emplace_back(vec);
905             }
906         }
907     } else {
908         for (auto vec : orderedEventQueue_) {
909             if (vec->commonEventData->GetWant().GetAction() == event && vec->userId == userId) {
910                 records.emplace_back(vec);
911             }
912         }
913     }
914 }
915 
GetHistoryEventRecords(const std::string & event,const int32_t & userId,std::list<HistoryEventRecord> & records)916 void CommonEventControlManager::GetHistoryEventRecords(
917     const std::string &event, const int32_t &userId, std::list<HistoryEventRecord> &records)
918 {
919     EVENT_LOGD("enter");
920     if (event.empty() && userId == ALL_USER) {
921         records = historyEventRecords_;
922     } else if (event.empty()) {
923         for (auto vec : historyEventRecords_) {
924             if (vec.userId == userId) {
925                 records.push_back(vec);
926             }
927         }
928     } else if (userId == ALL_USER) {
929         for (auto vec : historyEventRecords_) {
930             if (vec.want.GetAction() == event) {
931                 records.push_back(vec);
932             }
933         }
934     } else {
935         for (auto vec : historyEventRecords_) {
936             if (vec.want.GetAction() == event && vec.userId == userId) {
937                 records.push_back(vec);
938             }
939         }
940     }
941 }
942 
DumpStateByCommonEventRecord(const std::shared_ptr<OrderedEventRecord> & record,std::string & dumpInfo)943 void CommonEventControlManager::DumpStateByCommonEventRecord(
944     const std::shared_ptr<OrderedEventRecord> &record, std::string &dumpInfo)
945 {
946     EVENT_LOGD("enter");
947 
948     char systime[LENGTH];
949     strftime(systime, sizeof(char) * LENGTH, "%Y%m%d %I:%M %p", &record->recordTime);
950 
951     std::string recordTime = "\tTime: " + std::string(systime) + "\n";
952     std::string pid = "\tPID: " + std::to_string(record->eventRecordInfo.pid) + "\n";
953     std::string uid = "\tUID: " + std::to_string(record->eventRecordInfo.uid) + "\n";
954     std::string userId;
955     switch (record->userId) {
956         case UNDEFINED_USER:
957             userId = "UNDEFINED_USER";
958             break;
959         case ALL_USER:
960             userId = "ALL_USER";
961             break;
962         default:
963             userId = std::to_string(record->userId);
964             break;
965     }
966     userId = "\tUSERID: " + userId + "\n";
967     std::string bundleName = "\tBundleName: " + record->eventRecordInfo.bundleName + "\n";
968 
969     std::string permission = "\tRequiredPermission: ";
970     std::string separator;
971     size_t permissionNum = 0;
972     for (auto permissionVec : record->publishInfo->GetSubscriberPermissions()) {
973         if (permissionNum == 0) {
974             separator = "";
975         } else {
976             separator = ", ";
977         }
978         permission = permission + separator + permissionVec;
979         permissionNum++;
980     }
981     permission = permission + "\n";
982 
983     std::string isSticky;
984     if (record->publishInfo->IsSticky()) {
985         isSticky = "\tIsSticky: true\n";
986     } else {
987         isSticky = "\tIsSticky: false\n";
988     }
989 
990     std::string isOrdered;
991     if (record->publishInfo->IsOrdered()) {
992         isOrdered = "\tIsOrdered: true\n";
993     } else {
994         isOrdered = "\tIsOrdered: false\n";
995     }
996     std::string isSystemApp = record->eventRecordInfo.isSystemApp ? "true" : "false";
997     isSystemApp = "\tIsSystemApp: " + isSystemApp + "\n";
998     std::string isSystemEvent = record->isSystemEvent ? "true" : "false";
999     isSystemEvent = "\tIsSystemEvent: " + isSystemEvent + "\n";
1000 
1001     std::string action = "\t\tAction: " + record->commonEventData->GetWant().GetAction() + "\n";
1002 
1003     std::string entities = "\t\tEntity: ";
1004     size_t entityNum = 0;
1005     for (auto entitiesVec : record->commonEventData->GetWant().GetEntities()) {
1006         if (entityNum == 0) {
1007             separator = "";
1008         } else {
1009             separator = ", ";
1010         }
1011         entities = entities + separator + entitiesVec;
1012         entityNum++;
1013     }
1014     entities = entities + "\n";
1015 
1016     std::string scheme = "\t\tScheme: " + record->commonEventData->GetWant().GetScheme() + "\n";
1017     std::string uri = "\t\tUri: " + record->commonEventData->GetWant().GetUriString() + "\n";
1018     std::string flags = "\t\tFlags: " + std::to_string(record->commonEventData->GetWant().GetFlags()) + "\n";
1019     std::string type = "\t\tType: " + record->commonEventData->GetWant().GetType() + "\n";
1020     std::string bundle = "\t\tBundleName: " + record->commonEventData->GetWant().GetBundle() + "\n";
1021     std::string ability = "\t\tAbilityName: " + record->commonEventData->GetWant().GetElement().GetAbilityName() + "\n";
1022     std::string deviced = "\t\tDevicedID: " + record->commonEventData->GetWant().GetElement().GetDeviceID() + "\n";
1023 
1024     std::string want = "\tWant:\n" + action + entities + scheme + uri + flags + type + bundle + ability + deviced;
1025     std::string code = "\tCode: " + std::to_string(record->commonEventData->GetCode()) + "\n";
1026     std::string data = "\tData: " + record->commonEventData->GetData() + "\n";
1027 
1028     std::string lastSubscriber;
1029     if (record->resultTo) {
1030         lastSubscriber = "\tHasLastSubscriber: true\n";
1031     } else {
1032         lastSubscriber = "\tHasLastSubscriber: false\n";
1033     }
1034 
1035     std::string state;
1036     switch (record->state) {
1037         case OrderedEventRecord::IDLE:
1038             state = "\tEventState: IDLE\n";
1039             break;
1040         case OrderedEventRecord::RECEIVING:
1041             state = "\tEventState: RECEIVING\n";
1042             break;
1043         case OrderedEventRecord::RECEIVED:
1044             state = "\tEventState: RECEIVED\n";
1045             break;
1046     }
1047 
1048     std::string dispatchTime = "\tDispatchTime: " + std::to_string(record->dispatchTime) + "\n";
1049     std::string receiverTime = "\tReceiverTime: " + std::to_string(record->receiverTime) + "\n";
1050     std::string resultAbort = record->resultAbort ? "true" : "false";
1051     resultAbort = "\tResultAbort: " + resultAbort + "\n";
1052 
1053     dumpInfo = recordTime + pid + uid + userId + bundleName + permission + isSticky + isOrdered + isSystemApp +
1054                isSystemEvent + want + code + data + lastSubscriber + state + receiverTime + dispatchTime + resultAbort;
1055 }
1056 
DumpHistoryStateByCommonEventRecord(const HistoryEventRecord & record,std::string & dumpInfo)1057 void CommonEventControlManager::DumpHistoryStateByCommonEventRecord(
1058     const HistoryEventRecord &record, std::string &dumpInfo)
1059 {
1060     EVENT_LOGD("enter");
1061 
1062     char systime[LENGTH];
1063     strftime(systime, sizeof(char) * LENGTH, "%Y%m%d %I:%M %p", &record.recordTime);
1064 
1065     std::string recordTime = "\tTime: " + std::string(systime) + "\n";
1066     std::string pid = "\tPID: " + std::to_string(record.pid) + "\n";
1067     std::string uid = "\tUID: " + std::to_string(record.uid) + "\n";
1068     std::string userId;
1069     switch (record.userId) {
1070         case UNDEFINED_USER:
1071             userId = "UNDEFINED_USER";
1072             break;
1073         case ALL_USER:
1074             userId = "ALL_USER";
1075             break;
1076         default:
1077             userId = std::to_string(record.userId);
1078             break;
1079     }
1080     userId = "\tUSERID: " + userId + "\n";
1081     std::string bundleName = "\tBundleName: " + record.bundleName + "\n";
1082 
1083     std::string permission = "\tRequiredPermission: ";
1084     std::string separator;
1085     size_t permissionNum = 0;
1086     for (auto permissionVec : record.subscriberPermissions) {
1087         if (permissionNum == 0) {
1088             separator = "";
1089         } else {
1090             separator = ", ";
1091         }
1092         permission = permission + separator + permissionVec;
1093         permissionNum++;
1094     }
1095     permission = permission + "\n";
1096 
1097     std::string isSticky;
1098     if (record.sticky) {
1099         isSticky = "\tIsSticky: true\n";
1100     } else {
1101         isSticky = "\tIsSticky: false\n";
1102     }
1103 
1104     std::string isOrdered;
1105     if (record.ordered) {
1106         isOrdered = "\tIsOrdered: true\n";
1107     } else {
1108         isOrdered = "\tIsOrdered: false\n";
1109     }
1110     std::string isSystemApp = record.isSystemApp ? "true" : "false";
1111     isSystemApp = "\tIsSystemApp: " + isSystemApp + "\n";
1112     std::string isSystemEvent = record.isSystemEvent ? "true" : "false";
1113     isSystemEvent = "\tIsSystemEvent: " + isSystemEvent + "\n";
1114 
1115     std::string action = "\t\tAction: " + record.want.GetAction() + "\n";
1116 
1117     std::string entities = "\t\tEntity: ";
1118     size_t entityNum = 0;
1119     for (auto entitiesVec : record.want.GetEntities()) {
1120         if (entityNum == 0) {
1121             separator = "";
1122         } else {
1123             separator = ", ";
1124         }
1125         entities = entities + separator + entitiesVec;
1126         entityNum++;
1127     }
1128     entities = entities + "\n";
1129 
1130     std::string scheme = "\t\tScheme: " + record.want.GetScheme() + "\n";
1131     std::string uri = "\t\tUri: " + record.want.GetUriString() + "\n";
1132     std::string flags = "\t\tFlags: " + std::to_string(record.want.GetFlags()) + "\n";
1133     std::string type = "\t\tType: " + record.want.GetType() + "\n";
1134     std::string bundle = "\t\tBundleName: " + record.want.GetBundle() + "\n";
1135     std::string ability = "\t\tAbilityName: " + record.want.GetElement().GetAbilityName() + "\n";
1136     std::string deviced = "\t\tDevicedID: " + record.want.GetElement().GetDeviceID() + "\n";
1137 
1138     std::string want = "\tWant:\n" + action + entities + scheme + uri + flags + type + bundle + ability + deviced;
1139     std::string code = "\tCode: " + std::to_string(record.code) + "\n";
1140     std::string data = "\tData: " + record.data + "\n";
1141 
1142     std::string lastSubscriber;
1143     if (record.hasLastSubscribe) {
1144         lastSubscriber = "\tHasLastSubscriber: true\n";
1145     } else {
1146         lastSubscriber = "\tHasLastSubscriber: false\n";
1147     }
1148 
1149     std::string state;
1150     switch (record.state) {
1151         case OrderedEventRecord::IDLE:
1152             state = "\tEventState: IDLE\n";
1153             break;
1154         case OrderedEventRecord::RECEIVING:
1155             state = "\tEventState: RECEIVING\n";
1156             break;
1157         case OrderedEventRecord::RECEIVED:
1158             state = "\tEventState: RECEIVED\n";
1159             break;
1160     }
1161 
1162     std::string dispatchTime = "\tDispatchTime: " + std::to_string(record.dispatchTime) + "\n";
1163     std::string receiverTime = "\tReceiverTime: " + std::to_string(record.receiverTime) + "\n";
1164     std::string resultAbort = record.resultAbort ? "true" : "false";
1165     resultAbort = "\tResultAbort: " + resultAbort + "\n";
1166 
1167     dumpInfo = recordTime + pid + uid + userId + bundleName + permission + isSticky + isOrdered + isSystemApp +
1168                isSystemEvent + want + code + data + lastSubscriber + state + receiverTime + dispatchTime + resultAbort;
1169 }
1170 
DumpStateBySubscriberRecord(const std::shared_ptr<OrderedEventRecord> & record,std::string & dumpInfo)1171 void CommonEventControlManager::DumpStateBySubscriberRecord(
1172     const std::shared_ptr<OrderedEventRecord> &record, std::string &dumpInfo)
1173 {
1174     EVENT_LOGD("enter");
1175 
1176     if (record->receivers.empty()) {
1177         dumpInfo = "\tSubscribers:\tNo information";
1178         return;
1179     }
1180 
1181     size_t num = 0;
1182     for (auto receiver : record->receivers) {
1183         num++;
1184 
1185         std::string title = std::to_string(num);
1186         if (num == 1) {
1187             title = "\tSubscribers:\tTotal " + std::to_string(record->receivers.size()) + " subscribers\n\tNO " +
1188                     title + "\n";
1189         } else {
1190             title = "\tNO " + title + "\n";
1191         }
1192 
1193         std::string dumpInfoBySubscriber;
1194         DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->DumpDetailed(
1195             title, receiver, "\t\t", dumpInfoBySubscriber);
1196 
1197         std::string deliveryState;
1198         switch (record->deliveryState[num - 1]) {
1199             case OrderedEventRecord::PENDING:
1200                 deliveryState = "\t\tEventState: PENDING\n";
1201                 break;
1202             case OrderedEventRecord::DELIVERED:
1203                 deliveryState = "\t\tEventState: DELIVERED\n";
1204                 break;
1205             case OrderedEventRecord::SKIPPED:
1206                 deliveryState = "\t\tEventState: SKIPPED\n";
1207                 break;
1208             case OrderedEventRecord::TIMEOUT:
1209                 deliveryState = "\t\tEventState: TIMEOUT\n";
1210                 break;
1211         }
1212         dumpInfo = dumpInfo + dumpInfoBySubscriber + deliveryState;
1213     }
1214 }
1215 
DumpHistoryStateBySubscriberRecord(const HistoryEventRecord & record,std::string & dumpInfo)1216 void CommonEventControlManager::DumpHistoryStateBySubscriberRecord(
1217     const HistoryEventRecord &record, std::string &dumpInfo)
1218 {
1219     EVENT_LOGD("enter");
1220 
1221     if (record.receivers.empty()) {
1222         dumpInfo = "\tSubscribers:\tNo information";
1223         return;
1224     }
1225 
1226     size_t num = 0;
1227     for (auto receiver : record.receivers) {
1228         num++;
1229 
1230         std::string title = std::to_string(num);
1231         if (num == 1) {
1232             title = "\tSubscribers:\tTotal " + std::to_string(record.receivers.size()) +
1233                 " subscribers\n\tNO " + title + "\n";
1234         } else {
1235             title = "\tNO " + title + "\n";
1236         }
1237 
1238         char systime[LENGTH];
1239         strftime(systime, sizeof(char) * LENGTH, "%Y%m%d %I:%M %p", &receiver.recordTime);
1240         std::string format = "\t\t";
1241         std::string recordTime = format + "Time: " + std::string(systime) + "\n";
1242 
1243         std::string bundleName = format + "BundleName: " + receiver.bundleName + "\n";
1244         std::string priority = format + "Priority: " + std::to_string(receiver.priority) + "\n";
1245         std::string userId;
1246         switch (receiver.userId) {
1247             case UNDEFINED_USER:
1248                 userId = "UNDEFINED_USER";
1249                 break;
1250             case ALL_USER:
1251                 userId = "ALL_USER";
1252                 break;
1253             default:
1254                 userId = std::to_string(receiver.userId);
1255                 break;
1256         }
1257         userId = format + "USERID: " + userId + "\n";
1258         std::string permission = format + "Permission: " + receiver.permission + "\n";
1259         std::string deviceId = format + "DevicedID: " + receiver.deviceId + "\n";
1260 
1261         std::string isFreeze = receiver.isFreeze ? "true" : "false";
1262         isFreeze = format + "IsFreeze: " + isFreeze + "\n";
1263 
1264         std::string freezeTime;
1265         if (receiver.freezeTime == 0) {
1266             freezeTime = format + "FreezeTime:  -\n";
1267         } else {
1268             freezeTime = format + "FreezeTime: " + std::to_string(receiver.freezeTime) + "\n";
1269         }
1270 
1271         std::string deliveryState;
1272         switch (record.deliveryState[num - 1]) {
1273             case OrderedEventRecord::PENDING:
1274                 deliveryState = "\t\tEventState: PENDING\n";
1275                 break;
1276             case OrderedEventRecord::DELIVERED:
1277                 deliveryState = "\t\tEventState: DELIVERED\n";
1278                 break;
1279             case OrderedEventRecord::SKIPPED:
1280                 deliveryState = "\t\tEventState: SKIPPED\n";
1281                 break;
1282             case OrderedEventRecord::TIMEOUT:
1283                 deliveryState = "\t\tEventState: TIMEOUT\n";
1284                 break;
1285         }
1286         dumpInfo = dumpInfo + title + recordTime + bundleName + priority + userId + permission + deviceId + isFreeze +
1287                    freezeTime + deliveryState;
1288     }
1289 }
1290 
DumpState(const std::string & event,const int32_t & userId,std::vector<std::string> & state)1291 void CommonEventControlManager::DumpState(
1292     const std::string &event, const int32_t &userId, std::vector<std::string> &state)
1293 {
1294     EVENT_LOGD("enter");
1295 
1296     std::vector<std::shared_ptr<OrderedEventRecord>> records;
1297     std::vector<std::shared_ptr<OrderedEventRecord>> unorderedRecords;
1298     std::vector<std::shared_ptr<OrderedEventRecord>> orderedRecords;
1299     std::lock_guard<std::mutex> orderedLock(orderedMutex_);
1300     std::lock_guard<std::mutex> unorderedLock(unorderedMutex_);
1301     GetUnorderedEventRecords(event, userId, unorderedRecords);
1302     GetOrderedEventRecords(event, userId, orderedRecords);
1303     records.insert(records.end(), unorderedRecords.begin(), unorderedRecords.end());
1304     records.insert(records.end(), orderedRecords.begin(), orderedRecords.end());
1305 
1306     if (records.empty()) {
1307         state.emplace_back("Pending Events:\tNo information");
1308         return;
1309     }
1310 
1311     size_t num = 0;
1312     for (auto record : records) {
1313         num++;
1314 
1315         std::string no = std::to_string(num);
1316         if (num == 1) {
1317             no = "Pending Events:\tTotal " + std::to_string(records.size()) + " information\nNO " + no + "\n";
1318         } else {
1319             no = "NO " + no + "\n";
1320         }
1321         std::string commonEventRecord;
1322         DumpStateByCommonEventRecord(record, commonEventRecord);
1323         std::string subscriberRecord;
1324         DumpStateBySubscriberRecord(record, subscriberRecord);
1325         std::string stateInfo = no + commonEventRecord + subscriberRecord;
1326         state.emplace_back(stateInfo);
1327     }
1328 }
1329 
DumpHistoryState(const std::string & event,const int32_t & userId,std::vector<std::string> & state)1330 void CommonEventControlManager::DumpHistoryState(
1331     const std::string &event, const int32_t &userId, std::vector<std::string> &state)
1332 {
1333     EVENT_LOGD("enter");
1334 
1335     std::list<HistoryEventRecord> records;
1336     std::lock_guard<std::mutex> lock(historyMutex_);
1337     GetHistoryEventRecords(event, userId, records);
1338 
1339     if (records.empty()) {
1340         state.emplace_back("History Events:\tNo information");
1341         return;
1342     }
1343 
1344     size_t num = 0;
1345     for (auto record : records) {
1346         num++;
1347 
1348         std::string no = std::to_string(num);
1349         if (num == 1) {
1350             no = "History Events:\tTotal " + std::to_string(records.size()) + " information\nNO " + no + "\n";
1351         } else {
1352             no = "NO " + no + "\n";
1353         }
1354         std::string commonEventRecord;
1355         DumpHistoryStateByCommonEventRecord(record, commonEventRecord);
1356         std::string subscriberRecord;
1357         DumpHistoryStateBySubscriberRecord(record, subscriberRecord);
1358         std::string stateInfo = no + commonEventRecord + subscriberRecord;
1359         state.emplace_back(stateInfo);
1360     }
1361 }
1362 
SendOrderedEventProcTimeoutHiSysEvent(const std::shared_ptr<EventSubscriberRecord> & subscriberRecord,const std::string & eventName)1363 void CommonEventControlManager::SendOrderedEventProcTimeoutHiSysEvent(
1364     const std::shared_ptr<EventSubscriberRecord> &subscriberRecord, const std::string &eventName)
1365 {
1366     if (subscriberRecord == nullptr) {
1367         return;
1368     }
1369 
1370     EventInfo eventInfo;
1371     if (subscriberRecord->eventSubscribeInfo != nullptr) {
1372         eventInfo.userId = subscriberRecord->eventSubscribeInfo->GetUserId();
1373     }
1374     eventInfo.subscriberName = subscriberRecord->eventRecordInfo.bundleName;
1375     eventInfo.pid = subscriberRecord->eventRecordInfo.pid;
1376     eventInfo.uid = static_cast<int32_t>(subscriberRecord->eventRecordInfo.uid);
1377     eventInfo.eventName = eventName;
1378     EventReport::SendHiSysEvent(ORDERED_EVENT_PROC_TIMEOUT, eventInfo);
1379 }
1380 }  // namespace EventFwk
1381 }  // namespace OHOS