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.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_LOGI("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_LOGI("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_LOGI("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_LOGI("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 (!record.first || !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
129 handler_->PostImmediateTask(innerCallback);
130 }
131 }
132 }
133
NotifyFreezeEvents(const EventSubscriberRecord & subscriberRecord,const CommonEventRecord & eventRecord)134 bool CommonEventControlManager::NotifyFreezeEvents(
135 const EventSubscriberRecord &subscriberRecord, const CommonEventRecord &eventRecord)
136 {
137 EVENT_LOGI("enter");
138
139 sptr<IEventReceive> commonEventListenerProxy = iface_cast<IEventReceive>(subscriberRecord.commonEventListener);
140 if (!commonEventListenerProxy) {
141 EVENT_LOGE("Fail to get IEventReceive proxy");
142 return false;
143 }
144
145 int8_t ret = CheckPermission(subscriberRecord, eventRecord);
146 if (ret != OrderedEventRecord::DELIVERED) {
147 EVENT_LOGE("check permission is failed");
148 return false;
149 }
150 if (eventRecord.commonEventData == nullptr) {
151 EVENT_LOGE("commonEventData == nullptr");
152 return false;
153 }
154 EVENT_LOGI("Send common event %{public}s to subscriber %{public}s (pid = %{public}d, uid = %{public}d) "
155 "when unfreezed",
156 eventRecord.commonEventData->GetWant().GetAction().c_str(),
157 subscriberRecord.eventRecordInfo.bundleName.c_str(),
158 subscriberRecord.eventRecordInfo.pid,
159 subscriberRecord.eventRecordInfo.uid);
160 commonEventListenerProxy->NotifyEvent(*(eventRecord.commonEventData),
161 false, eventRecord.publishInfo->IsSticky());
162 AccessTokenHelper::RecordSensitivePermissionUsage(subscriberRecord.eventRecordInfo.callerToken,
163 eventRecord.commonEventData->GetWant().GetAction());
164 return true;
165 }
166
GetUnorderedEventHandler()167 bool CommonEventControlManager::GetUnorderedEventHandler()
168 {
169 if (!handler_) {
170 handler_ = std::make_shared<EventHandler>(EventRunner::Create("CesSrvUnorderEventHandler"));
171 if (!handler_) {
172 EVENT_LOGE("Failed to create UnorderedEventHandler");
173 return false;
174 }
175 }
176 if (handler_->GetEventRunner() != nullptr) {
177 std::string threadName = handler_->GetEventRunner()->GetRunnerThreadName();
178 if (HiviewDFX::Watchdog::GetInstance().AddThread(threadName, handler_) != 0) {
179 EVENT_LOGE("Failed to Add handler Thread");
180 }
181 }
182 return true;
183 }
184
NotifyUnorderedEvent(std::shared_ptr<OrderedEventRecord> & eventRecord)185 bool CommonEventControlManager::NotifyUnorderedEvent(std::shared_ptr<OrderedEventRecord> &eventRecord)
186 {
187 HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
188 EVENT_LOGI("enter");
189 if (!eventRecord) {
190 EVENT_LOGI("Invalid event record.");
191 return false;
192 }
193 std::lock_guard<std::mutex> lock(unorderedMutex_);
194 EVENT_LOGI("event = %{public}s, receivers size = %{public}zu",
195 eventRecord->commonEventData->GetWant().GetAction().c_str(), eventRecord->receivers.size());
196 for (auto vec : eventRecord->receivers) {
197 if (vec == nullptr) {
198 EVENT_LOGE("invalid vec");
199 continue;
200 }
201 size_t index = eventRecord->nextReceiver++;
202 eventRecord->curReceiver = vec->commonEventListener;
203 if (vec->isFreeze) {
204 eventRecord->deliveryState[index] = OrderedEventRecord::SKIPPED;
205 DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->InsertFrozenEvents(vec, *eventRecord);
206 } else {
207 sptr<IEventReceive> commonEventListenerProxy = iface_cast<IEventReceive>(vec->commonEventListener);
208 if (!commonEventListenerProxy) {
209 eventRecord->deliveryState[index] = OrderedEventRecord::SKIPPED;
210 EVENT_LOGE("Failed to get IEventReceive proxy");
211 continue;
212 }
213 int8_t ret = CheckPermission(*vec, *eventRecord);
214 eventRecord->deliveryState[index] = ret;
215 if (ret == OrderedEventRecord::DELIVERED) {
216 eventRecord->state = OrderedEventRecord::RECEIVING;
217 commonEventListenerProxy->NotifyEvent(
218 *(eventRecord->commonEventData), false, eventRecord->publishInfo->IsSticky());
219 eventRecord->state = OrderedEventRecord::RECEIVED;
220 AccessTokenHelper::RecordSensitivePermissionUsage(vec->eventRecordInfo.callerToken,
221 eventRecord->commonEventData->GetWant().GetAction());
222 }
223 }
224 }
225
226 EnqueueHistoryEventRecord(eventRecord, false);
227
228 auto it = std::find(unorderedEventQueue_.begin(), unorderedEventQueue_.end(), eventRecord);
229 if (it != unorderedEventQueue_.end()) {
230 unorderedEventQueue_.erase(it);
231 }
232 return true;
233 }
234
ProcessUnorderedEvent(const CommonEventRecord & eventRecord,const std::shared_ptr<EventSubscriberRecord> & subscriberRecord)235 bool CommonEventControlManager::ProcessUnorderedEvent(
236 const CommonEventRecord &eventRecord, const std::shared_ptr<EventSubscriberRecord> &subscriberRecord)
237 {
238 HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
239 EVENT_LOGI("enter");
240
241 bool ret = false;
242
243 if (!GetUnorderedEventHandler()) {
244 EVENT_LOGE("failed to get eventhandler");
245 return ret;
246 }
247
248 std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
249 if (eventRecordPtr == nullptr) {
250 EVENT_LOGE("eventRecordPtr is null");
251 return ret;
252 }
253
254 std::shared_ptr<CommonEventSubscriberManager> spinstance =
255 DelayedSingleton<CommonEventSubscriberManager>::GetInstance();
256
257 eventRecordPtr->FillCommonEventRecord(eventRecord);
258 if (subscriberRecord) {
259 eventRecordPtr->receivers.emplace_back(subscriberRecord);
260 } else {
261 eventRecordPtr->receivers = spinstance->GetSubscriberRecords(eventRecord);
262 }
263
264 for (auto vec : eventRecordPtr->receivers) {
265 eventRecordPtr->deliveryState.emplace_back(OrderedEventRecord::PENDING);
266 }
267
268 EnqueueUnorderedRecord(eventRecordPtr);
269
270 std::weak_ptr<CommonEventControlManager> weak = shared_from_this();
271 auto innerCallback = [weak, eventRecordPtr]() {
272 auto manager = weak.lock();
273 if (manager == nullptr) {
274 EVENT_LOGE("CommonEventControlManager is null");
275 return;
276 }
277 std::shared_ptr<OrderedEventRecord> ordered = eventRecordPtr;
278 manager->NotifyUnorderedEvent(ordered);
279 };
280
281 if (eventRecord.isSystemEvent) {
282 ret = handler_->PostImmediateTask(innerCallback);
283 } else {
284 ret = handler_->PostTask(innerCallback);
285 }
286
287 return ret;
288 }
289
GetMatchingOrderedReceiver(const sptr<IRemoteObject> & proxy)290 std::shared_ptr<OrderedEventRecord> CommonEventControlManager::GetMatchingOrderedReceiver(
291 const sptr<IRemoteObject> &proxy)
292 {
293 EVENT_LOGI("enter");
294
295 std::lock_guard<std::mutex> lock(orderedMutex_);
296
297 if (!orderedEventQueue_.empty()) {
298 std::shared_ptr<OrderedEventRecord> firstRecord = orderedEventQueue_.front();
299 if ((firstRecord != nullptr) && (firstRecord->curReceiver == proxy)) {
300 return firstRecord;
301 }
302 }
303
304 return nullptr;
305 }
306
GetOrderedEventHandler()307 bool CommonEventControlManager::GetOrderedEventHandler()
308 {
309 if (!handlerOrdered_) {
310 handlerOrdered_ = std::make_shared<OrderedEventHandler>(
311 EventRunner::Create("CesSrvOrderEventHandler"), shared_from_this());
312 if (!handlerOrdered_) {
313 EVENT_LOGE("Failed to create OrderedEventHandler");
314 return false;
315 }
316 }
317 if (handlerOrdered_->GetEventRunner() != nullptr) {
318 std::string threadName = handlerOrdered_->GetEventRunner()->GetRunnerThreadName();
319 if (HiviewDFX::Watchdog::GetInstance().AddThread(threadName, handlerOrdered_) != 0) {
320 EVENT_LOGE("Failed to Add Ordered Thread");
321 }
322 }
323 return true;
324 }
325
ProcessOrderedEvent(const CommonEventRecord & eventRecord,const sptr<IRemoteObject> & commonEventListener)326 bool CommonEventControlManager::ProcessOrderedEvent(
327 const CommonEventRecord &eventRecord, const sptr<IRemoteObject> &commonEventListener)
328 {
329 HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
330 EVENT_LOGI("enter");
331
332 bool ret = false;
333
334 if (!GetOrderedEventHandler()) {
335 EVENT_LOGE("failed to get eventhandler");
336 return ret;
337 }
338
339 std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
340 if (eventRecordPtr == nullptr) {
341 EVENT_LOGE("eventRecordPtr is null");
342 return ret;
343 }
344
345 std::shared_ptr<CommonEventSubscriberManager> spinstance =
346 DelayedSingleton<CommonEventSubscriberManager>::GetInstance();
347
348 eventRecordPtr->FillCommonEventRecord(eventRecord);
349 eventRecordPtr->resultTo = commonEventListener;
350 eventRecordPtr->state = OrderedEventRecord::IDLE;
351 eventRecordPtr->nextReceiver = 0;
352 eventRecordPtr->receivers = spinstance->GetSubscriberRecords(eventRecord);
353 for (auto vec : eventRecordPtr->receivers) {
354 eventRecordPtr->deliveryState.emplace_back(OrderedEventRecord::PENDING);
355 }
356
357 EnqueueOrderedRecord(eventRecordPtr);
358
359 ret = ScheduleOrderedCommonEvent();
360
361 return ret;
362 }
363
EnqueueUnorderedRecord(const std::shared_ptr<OrderedEventRecord> & eventRecordPtr)364 bool CommonEventControlManager::EnqueueUnorderedRecord(const std::shared_ptr<OrderedEventRecord> &eventRecordPtr)
365 {
366 if (eventRecordPtr == nullptr) {
367 EVENT_LOGE("eventRecordPtr is null");
368 return false;
369 }
370
371 std::lock_guard<std::mutex> lock(unorderedMutex_);
372
373 unorderedEventQueue_.emplace_back(eventRecordPtr);
374
375 return true;
376 }
377
EnqueueOrderedRecord(const std::shared_ptr<OrderedEventRecord> & eventRecordPtr)378 bool CommonEventControlManager::EnqueueOrderedRecord(const std::shared_ptr<OrderedEventRecord> &eventRecordPtr)
379 {
380 if (eventRecordPtr == nullptr) {
381 EVENT_LOGE("eventRecordPtr is null");
382 return false;
383 }
384
385 std::lock_guard<std::mutex> lock(orderedMutex_);
386
387 orderedEventQueue_.emplace_back(eventRecordPtr);
388
389 return true;
390 }
391
EnqueueHistoryEventRecord(const std::shared_ptr<OrderedEventRecord> & eventRecordPtr,bool hasLastSubscribe)392 void CommonEventControlManager::EnqueueHistoryEventRecord(
393 const std::shared_ptr<OrderedEventRecord> &eventRecordPtr, bool hasLastSubscribe)
394 {
395 EVENT_LOGI("enter");
396
397 if (eventRecordPtr == nullptr) {
398 EVENT_LOGE("eventRecordPtr is nullptr");
399 return;
400 }
401
402 HistoryEventRecord record;
403 record.want = eventRecordPtr->commonEventData->GetWant();
404 record.code = eventRecordPtr->commonEventData->GetCode();
405 record.data = eventRecordPtr->commonEventData->GetData();
406
407 record.sticky = eventRecordPtr->publishInfo->IsSticky();
408 record.ordered = eventRecordPtr->publishInfo->IsOrdered();
409 record.subscriberPermissions = eventRecordPtr->publishInfo->GetSubscriberPermissions();
410
411 record.recordTime = eventRecordPtr->recordTime;
412 record.pid = eventRecordPtr->eventRecordInfo.pid;
413 record.uid = eventRecordPtr->eventRecordInfo.uid;
414 record.userId = eventRecordPtr->userId;
415 record.bundleName = eventRecordPtr->eventRecordInfo.bundleName;
416 record.isSystemApp = eventRecordPtr->eventRecordInfo.isSystemApp;
417 record.isSystemEvent = eventRecordPtr->isSystemEvent;
418
419 for (auto vec : eventRecordPtr->receivers) {
420 if (vec == nullptr) {
421 continue;
422 }
423 HistorySubscriberRecord receiver;
424 receiver.recordTime = vec->recordTime;
425 receiver.bundleName = vec->eventRecordInfo.bundleName;
426 receiver.priority = vec->eventSubscribeInfo->GetPriority();
427 receiver.userId = vec->eventSubscribeInfo->GetUserId();
428 receiver.permission = vec->eventSubscribeInfo->GetPermission();
429 receiver.deviceId = vec->eventSubscribeInfo->GetDeviceId();
430 receiver.isFreeze = vec->isFreeze;
431 receiver.freezeTime = vec->freezeTime;
432 record.receivers.emplace_back(receiver);
433 }
434
435 record.hasLastSubscribe = hasLastSubscribe;
436 record.deliveryState = eventRecordPtr->deliveryState;
437 record.dispatchTime = eventRecordPtr->dispatchTime;
438 record.receiverTime = eventRecordPtr->receiverTime;
439 record.state = eventRecordPtr->state;
440 record.resultAbort = eventRecordPtr->resultAbort;
441
442 std::lock_guard<std::mutex> lock(historyMutex_);
443 if (historyEventRecords_.size() == HISTORY_MAX_SIZE) {
444 historyEventRecords_.erase(historyEventRecords_.begin());
445 }
446 historyEventRecords_.emplace_back(record);
447 }
448
ScheduleOrderedCommonEvent()449 bool CommonEventControlManager::ScheduleOrderedCommonEvent()
450 {
451 EVENT_LOGI("enter");
452
453 if (scheduled_) {
454 return true;
455 }
456
457 scheduled_ = true;
458
459 return handlerOrdered_->SendEvent(InnerEvent::Get(OrderedEventHandler::ORDERED_EVENT_START));
460 }
461
NotifyOrderedEvent(std::shared_ptr<OrderedEventRecord> & eventRecordPtr,size_t index)462 bool CommonEventControlManager::NotifyOrderedEvent(std::shared_ptr<OrderedEventRecord> &eventRecordPtr, size_t index)
463 {
464 HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
465 EVENT_LOGI("enter with index %{public}zu", index);
466 if (eventRecordPtr == nullptr) {
467 EVENT_LOGE("eventRecordPtr = nullptr");
468 return false;
469 }
470 size_t receiverNum = eventRecordPtr->receivers.size();
471 if ((index < 0) || (index >= receiverNum)) {
472 EVENT_LOGE("Invalid index (= %{public}zu)", index);
473 return false;
474 }
475 int8_t ret = CheckPermission(*(eventRecordPtr->receivers[index]), *eventRecordPtr);
476 if (ret == OrderedEventRecord::SKIPPED) {
477 eventRecordPtr->deliveryState[index] = ret;
478 return true;
479 }
480 if (ret == OrderedEventRecord::DELIVERED) {
481 if (eventRecordPtr->receivers[index]->isFreeze) {
482 EVENT_LOGI("vec isFreeze: %{public}d", eventRecordPtr->receivers[index]->isFreeze);
483 DelayedSingleton<CommonEventSubscriberManager>::GetInstance()->InsertFrozenEvents(
484 eventRecordPtr->receivers[index], *eventRecordPtr);
485 eventRecordPtr->deliveryState[index] = OrderedEventRecord::SKIPPED;
486 eventRecordPtr->curReceiver = nullptr;
487 return true;
488 }
489 eventRecordPtr->deliveryState[index] = ret;
490 eventRecordPtr->curReceiver = eventRecordPtr->receivers[index]->commonEventListener;
491 eventRecordPtr->state = OrderedEventRecord::RECEIVING;
492 sptr<IEventReceive> receiver = iface_cast<IEventReceive>(eventRecordPtr->curReceiver);
493 if (!receiver) {
494 EVENT_LOGE("Failed to get IEventReceive proxy");
495 eventRecordPtr->curReceiver = nullptr;
496 return false;
497 }
498 eventRecordPtr->state = OrderedEventRecord::RECEIVED;
499 EVENT_LOGI("NotifyOrderedEvent event = %{public}s",
500 eventRecordPtr->commonEventData->GetWant().GetAction().c_str());
501 receiver->NotifyEvent(*(eventRecordPtr->commonEventData), true, eventRecordPtr->publishInfo->IsSticky());
502 AccessTokenHelper::RecordSensitivePermissionUsage(
503 eventRecordPtr->receivers[index]->eventRecordInfo.callerToken,
504 eventRecordPtr->commonEventData->GetWant().GetAction());
505 }
506 return true;
507 }
508
ProcessNextOrderedEvent(bool isSendMsg)509 void CommonEventControlManager::ProcessNextOrderedEvent(bool isSendMsg)
510 {
511 HITRACE_METER_NAME(HITRACE_TAG_NOTIFICATION, __PRETTY_FUNCTION__);
512 EVENT_LOGI("enter");
513
514 if (isSendMsg) {
515 scheduled_ = false;
516 }
517
518 std::shared_ptr<OrderedEventRecord> sp = nullptr;
519
520 std::lock_guard<std::mutex> lock(orderedMutex_);
521
522 do {
523 if (orderedEventQueue_.empty()) {
524 EVENT_LOGE("orderedEventQueue_ is empty");
525 return;
526 }
527
528 sp = orderedEventQueue_.front();
529 bool forceReceive = false;
530 size_t numReceivers = sp->receivers.size();
531 uint64_t nowSysTime = static_cast<uint64_t>(SystemTime::GetNowSysTime());
532
533 if (sp->dispatchTime > 0) {
534 if ((numReceivers > 0) && (nowSysTime > static_cast<uint64_t>(sp->dispatchTime) +
535 (DOUBLE * TIMEOUT * numReceivers))) {
536 CurrentOrderedEventTimeout(false);
537 forceReceive = true;
538 sp->state = OrderedEventRecord::IDLE;
539 }
540 }
541
542 if (sp->state != OrderedEventRecord::IDLE) {
543 return;
544 }
545
546 if ((sp->receivers.empty()) || (sp->nextReceiver >= numReceivers) || sp->resultAbort || forceReceive) {
547 // No more receivers for this ordered common event, then process the final result receiver
548 bool hasLastSubscribe = (sp->resultTo != nullptr) ? true : false;
549 if (sp->resultTo != nullptr) {
550 EVENT_LOGI("Process the final subscriber");
551 sptr<IEventReceive> receiver = iface_cast<IEventReceive>(sp->resultTo);
552 if (!receiver) {
553 EVENT_LOGE("Failed to get IEventReceive proxy");
554 return;
555 }
556 receiver->NotifyEvent(*(sp->commonEventData), true, sp->publishInfo->IsSticky());
557 sp->resultTo = nullptr;
558 }
559
560 CancelTimeout();
561
562 EnqueueHistoryEventRecord(sp, hasLastSubscribe);
563
564 orderedEventQueue_.erase(orderedEventQueue_.begin());
565
566 sp = nullptr;
567 }
568 } while (sp == nullptr);
569
570 size_t recIdx = sp->nextReceiver++;
571 SetTime(recIdx, sp, pendingTimeoutMessage_);
572
573 NotifyOrderedEvent(sp, recIdx);
574 if (sp->curReceiver == nullptr) {
575 sp->state = OrderedEventRecord::IDLE;
576 ScheduleOrderedCommonEvent();
577 }
578 }
579
SetTime(size_t recIdx,std::shared_ptr<OrderedEventRecord> & sp,bool timeoutMessage)580 void CommonEventControlManager::SetTime(size_t recIdx, std::shared_ptr<OrderedEventRecord> &sp, bool timeoutMessage)
581 {
582 EVENT_LOGI("enter");
583
584 sp->receiverTime = SystemTime::GetNowSysTime();
585
586 if (recIdx == 0) {
587 sp->dispatchTime = sp->receiverTime;
588 }
589
590 if (!timeoutMessage) {
591 int64_t timeoutTime = sp->receiverTime + TIMEOUT;
592 SetTimeout(timeoutTime);
593 }
594 }
595
SetTimeout(int64_t timeoutTime)596 bool CommonEventControlManager::SetTimeout(int64_t timeoutTime)
597 {
598 EVENT_LOGI("enter");
599
600 bool ret = true;
601
602 if (!pendingTimeoutMessage_) {
603 pendingTimeoutMessage_ = true;
604 ret = handlerOrdered_->SendTimingEvent(OrderedEventHandler::ORDERED_EVENT_TIMEOUT, timeoutTime);
605 }
606
607 return ret;
608 }
609
CancelTimeout()610 bool CommonEventControlManager::CancelTimeout()
611 {
612 EVENT_LOGI("enter");
613
614 if (pendingTimeoutMessage_) {
615 pendingTimeoutMessage_ = false;
616 handlerOrdered_->RemoveEvent(OrderedEventHandler::ORDERED_EVENT_TIMEOUT);
617 }
618
619 return true;
620 }
621
CurrentOrderedEventTimeout(bool isFromMsg)622 void CommonEventControlManager::CurrentOrderedEventTimeout(bool isFromMsg)
623 {
624 EVENT_LOGI("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(timeoutTime);
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_LOGI("enter");
676
677 if (recordPtr == nullptr) {
678 EVENT_LOGE("recordPtr is null");
679 return false;
680 }
681
682 EVENT_LOGI("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_LOGI("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_LOGI("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_LOGI("enter");
743 bool ret = false;
744 std::string lackPermission {};
745
746 Permission permission = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(
747 eventRecord.commonEventData->GetWant().GetAction());
748 if (permission.names.empty()) {
749 return true;
750 }
751
752 if (!subscriberRecord.eventRecordInfo.isProxy && (subscriberRecord.eventRecordInfo.isSubsystem
753 || subscriberRecord.eventRecordInfo.isSystemApp)) {
754 return true;
755 }
756
757 if (permission.names.size() == 1) {
758 ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, permission.names[0]);
759 lackPermission = permission.names[0];
760 } else {
761 if (permission.state == PermissionState::AND) {
762 for (auto vec : permission.names) {
763 ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, vec);
764 if (!ret) {
765 lackPermission = vec;
766 break;
767 }
768 }
769 } else if (permission.state == PermissionState::OR) {
770 for (auto vec : permission.names) {
771 ret = AccessTokenHelper::VerifyAccessToken(subscriberRecord.eventRecordInfo.callerToken, vec);
772 lackPermission += vec + CONNECTOR;
773 if (ret) {
774 break;
775 }
776 }
777 lackPermission = lackPermission.substr(0, lackPermission.length() - CONNECTOR.length());
778 } else {
779 EVENT_LOGW("Invalid Permission.");
780 return false;
781 }
782 }
783 if (!ret) {
784 EVENT_LOGW("No permission to receive common event %{public}s, "
785 "due to subscriber %{public}s (pid = %{public}d, uid = %{public}d) lacks "
786 "the %{public}s permission.",
787 eventRecord.commonEventData->GetWant().GetAction().c_str(),
788 subscriberRecord.eventRecordInfo.bundleName.c_str(),
789 subscriberRecord.eventRecordInfo.pid,
790 subscriberRecord.eventRecordInfo.uid,
791 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()) {
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()) {
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_LOGI("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_LOGI("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::vector<HistoryEventRecord> & records)916 void CommonEventControlManager::GetHistoryEventRecords(
917 const std::string &event, const int32_t &userId, std::vector<HistoryEventRecord> &records)
918 {
919 EVENT_LOGI("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.emplace_back(vec);
926 }
927 }
928 } else if (userId == ALL_USER) {
929 for (auto vec : historyEventRecords_) {
930 if (vec.want.GetAction() == event) {
931 records.emplace_back(vec);
932 }
933 }
934 } else {
935 for (auto vec : historyEventRecords_) {
936 if (vec.want.GetAction() == event && vec.userId == userId) {
937 records.emplace_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_LOGI("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_LOGI("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_LOGI("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_LOGI("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_LOGI("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_LOGI("enter");
1334
1335 std::vector<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