1 /*
2 * Copyright (c) 2024 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 "adapter/mmi_adapter.h"
17
18 #include <mutex>
19 #include <thread>
20 #include <sys/prctl.h>
21
22 #include "dtbschedmgr_log.h"
23 #include "mission/dms_continue_send_manager.h"
24
25 namespace OHOS {
26 namespace DistributedSchedule {
27
28 namespace {
29 const std::string TAG = "MMIAdapter";
30 const std::string MMI_ADAPTER = "mmi_adapter";
31 const std::string FREEZE_MMI_EVENT_TASK = "task_freeze_mmi_event";
32 constexpr int32_t FREEZE_MMI_EVENT_INTERVAL = 5000;
33 }
34
35 IMPLEMENT_SINGLE_INSTANCE(MMIAdapter);
36
Init()37 void MMIAdapter::Init()
38 {
39 HILOGI("Init");
40 mmiCallback_ = std::make_shared<MMIAdapter::MMIEventCallback>();
41 eventThread_ = std::thread(&MMIAdapter::StartEvent, this);
42 std::unique_lock<std::mutex> lock(eventMutex_);
43 eventCon_.wait(lock, [this] {
44 return eventHandler_ != nullptr;
45 });
46 }
47
StartEvent()48 void MMIAdapter::StartEvent()
49 {
50 HILOGI("StartEvent start");
51 prctl(PR_SET_NAME, MMI_ADAPTER.c_str());
52 auto runner = AppExecFwk::EventRunner::Create(false);
53 {
54 std::lock_guard<std::mutex> lock(eventMutex_);
55 eventHandler_ = std::make_shared<OHOS::AppExecFwk::EventHandler>(runner);
56 }
57 eventCon_.notify_one();
58 runner->Run();
59 HILOGI("StartEvent end");
60 }
61
UnInit()62 void MMIAdapter::UnInit()
63 {
64 HILOGI("UnInit start");
65 if (eventHandler_ != nullptr) {
66 eventHandler_->GetEventRunner()->Stop();
67 eventThread_.join();
68 eventHandler_ = nullptr;
69 } else {
70 HILOGE("eventHandler_ is nullptr");
71 }
72 HILOGI("UnInit end");
73 }
74
AddMMIListener()75 int32_t MMIAdapter::AddMMIListener()
76 {
77 HILOGD("AddMMIListener called");
78 int32_t ret = MMI::InputManager::GetInstance()->AddMonitor(mmiCallback_);
79 HILOGD("AddMMIListener result: %{public}d", ret);
80 isMMIFreezed_ = false;
81 return ret;
82 }
83
RemoveMMIListener(int32_t monitorId)84 void MMIAdapter::RemoveMMIListener(int32_t monitorId)
85 {
86 HILOGD("RemoveMMIListener called, monitor id = %{public}d", monitorId);
87 MMI::InputManager::GetInstance()->RemoveMonitor(monitorId);
88 return;
89 }
90
PostRawMMIEvent()91 void MMIAdapter::PostRawMMIEvent()
92 {
93 auto func = [this]() {
94 HandleRawMMIEvent();
95 };
96 if (eventHandler_ != nullptr) {
97 eventHandler_->PostTask(func);
98 } else {
99 HILOGE("eventHandler_ is nullptr");
100 }
101 }
102
PostUnfreezeMMIEvent()103 void MMIAdapter::PostUnfreezeMMIEvent()
104 {
105 auto func = [this]() {
106 HandleUnfreezeMMIEvent();
107 };
108 if (eventHandler_ != nullptr) {
109 eventHandler_->PostTask(func, FREEZE_MMI_EVENT_TASK, FREEZE_MMI_EVENT_INTERVAL);
110 } else {
111 HILOGE("eventHandler_ is nullptr");
112 }
113 }
114
HandleRawMMIEvent()115 void MMIAdapter::HandleRawMMIEvent()
116 {
117 if (isMMIFreezed_) {
118 return;
119 }
120 isMMIFreezed_ = true;
121 DMSContinueSendMgr::GetInstance().OnMMIEvent();
122 PostUnfreezeMMIEvent();
123 }
124
HandleUnfreezeMMIEvent()125 void MMIAdapter::HandleUnfreezeMMIEvent()
126 {
127 isMMIFreezed_ = false;
128 }
129
OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const130 void MMIAdapter::MMIEventCallback::OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const
131 {
132 MMIAdapter::GetInstance().PostRawMMIEvent();
133 }
134
OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const135 void MMIAdapter::MMIEventCallback::OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const
136 {
137 MMIAdapter::GetInstance().PostRawMMIEvent();
138 }
139
OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const140 void MMIAdapter::MMIEventCallback::OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const
141 {
142 MMIAdapter::GetInstance().PostRawMMIEvent();
143 }
144 } // namespace DistributedSchedule
145 } // namespace OHOS
146