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
22namespace OHOS {
23namespace AAFwk {
24EventHandlerWrap::EventHandlerWrap() : taskHandler_(TaskHandlerWrap::GetFfrtHandler())
25{
26    eventMutex_ = std::make_unique<ffrt::mutex>();
27}
28
29EventHandlerWrap::EventHandlerWrap(std::shared_ptr<TaskHandlerWrap> taskHandler)
30    : taskHandler_(taskHandler)
31{
32    eventMutex_ = std::make_unique<ffrt::mutex>();
33}
34
35EventHandlerWrap::~EventHandlerWrap() = default;
36
37void EventHandlerWrap::ProcessEvent(const EventWrap &event)
38{
39    if (eventCallback_) {
40        eventCallback_(event);
41    }
42}
43bool EventHandlerWrap::SendEvent(uint32_t eventId)
44{
45    return SendEvent(EventWrap(eventId, 0));
46}
47bool EventHandlerWrap::SendEvent(uint32_t eventId, int64_t delayMillis)
48{
49    return SendEvent(EventWrap(eventId, 0), delayMillis);
50}
51bool EventHandlerWrap::SendEvent(EventWrap event)
52{
53    return SendEvent(event, 0);
54}
55bool 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
84bool EventHandlerWrap::RemoveEvent(uint32_t eventId, int64_t param)
85{
86    return RemoveEvent(EventWrap(eventId, param));
87}
88
89bool 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