1 /*
2 * Copyright (c) 2023 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 "event_handler_wrap.h"
17
18 #include <mutex>
19 #include "cpp/mutex.h"
20
21 namespace OHOS {
22 namespace AAFwk {
EventHandlerWrap()23 EventHandlerWrap::EventHandlerWrap() : taskHandler_(TaskHandlerWrap::GetFfrtHandler())
24 {
25 eventMutex_ = std::make_unique<ffrt::mutex>();
26 }
27
EventHandlerWrap(std::shared_ptr<TaskHandlerWrap> taskHandler)28 EventHandlerWrap::EventHandlerWrap(std::shared_ptr<TaskHandlerWrap> taskHandler)
29 : taskHandler_(taskHandler)
30 {
31 eventMutex_ = std::make_unique<ffrt::mutex>();
32 }
33
34 EventHandlerWrap::~EventHandlerWrap() = default;
35
ProcessEvent(const EventWrap & event)36 void EventHandlerWrap::ProcessEvent(const EventWrap &event)
37 {
38 if (eventCallback_) {
39 eventCallback_(event);
40 }
41 }
SendEvent(uint32_t eventId)42 bool EventHandlerWrap::SendEvent(uint32_t eventId)
43 {
44 return SendEvent(EventWrap(eventId, 0));
45 }
SendEvent(uint32_t eventId,int64_t delayMillis)46 bool EventHandlerWrap::SendEvent(uint32_t eventId, int64_t delayMillis)
47 {
48 return SendEvent(EventWrap(eventId, 0), delayMillis);
49 }
SendEvent(EventWrap event)50 bool EventHandlerWrap::SendEvent(EventWrap event)
51 {
52 return SendEvent(event, 0);
53 }
SendEvent(EventWrap event,int64_t delayMillis,bool forceInsert)54 bool EventHandlerWrap::SendEvent(EventWrap event, int64_t delayMillis, bool forceInsert)
55 {
56 if (!taskHandler_) {
57 return false;
58 }
59 auto eventStr = event.GetEventString();
60 std::lock_guard<ffrt::mutex> guard(*eventMutex_);
61 auto it = eventMap_.find(eventStr);
62 if (it != eventMap_.end() && !forceInsert) {
63 return false;
64 }
65
66 event.SetEventTask(taskHandler_->SubmitTask([wthis = weak_from_this(), event]() {
67 auto pthis = wthis.lock();
68 if (pthis) {
69 pthis->ProcessEvent(event);
70 pthis->RemoveEvent(event, false);
71 }
72 }, delayMillis));
73
74 if (it != eventMap_.end()) {
75 it->second = event;
76 } else {
77 eventMap_.emplace(eventStr, event);
78 }
79
80 return true;
81 }
82
RemoveEvent(uint32_t eventId,int64_t param)83 bool EventHandlerWrap::RemoveEvent(uint32_t eventId, int64_t param)
84 {
85 return RemoveEvent(EventWrap(eventId, param));
86 }
87
RemoveEvent(EventWrap event,bool force)88 bool EventHandlerWrap::RemoveEvent(EventWrap event, bool force)
89 {
90 std::lock_guard<ffrt::mutex> guard(*eventMutex_);
91 auto it = eventMap_.find(event.GetEventString());
92 if (it == eventMap_.end()) {
93 return false;
94 }
95 if (force || it->second.IsSame(event)) {
96 it->second.GetEventTask().Cancel();
97 eventMap_.erase(it);
98 return true;
99 }
100 return false;
101 }
102 } // namespace AAFWK
103 } // namespace OHOS