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