1 /*
2 * Copyright (c) 2025 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 "input_active_subscribe_manager.h"
17 #include "define_multimodal.h"
18 #include "error_multimodal.h"
19 #include "multimodal_event_handler.h"
20 #include "multimodal_input_connect_manager.h"
21
22 #undef MMI_LOG_TAG
23 #define MMI_LOG_TAG "InputActiveSubscribeManager"
24
25 namespace OHOS {
26 namespace MMI {
27 namespace {
28 constexpr int32_t INVALID_SUBSCRIBE_ID { -1 };
29 constexpr int32_t CURRENT_SUBSCRIBE_ID { 0 };
30 }
31
InputActiveSubscribeManager()32 InputActiveSubscribeManager::InputActiveSubscribeManager() {}
~InputActiveSubscribeManager()33 InputActiveSubscribeManager::~InputActiveSubscribeManager() {}
34
SubscribeInputActive(std::shared_ptr<IInputEventConsumer> inputEventConsumer,int64_t interval)35 int32_t InputActiveSubscribeManager::SubscribeInputActive(
36 std::shared_ptr<IInputEventConsumer> inputEventConsumer, int64_t interval)
37 {
38 CALL_DEBUG_ENTER;
39 CHKPR(inputEventConsumer, INVALID_SUBSCRIBE_ID);
40 CHKPR(MULTIMODAL_INPUT_CONNECT_MGR, INVALID_SUBSCRIBE_ID);
41 if (!MMIEventHdl.InitClient()) {
42 MMI_HILOGE("Client init failed");
43 return ERROR_INIT_CLIENT_FAILED;
44 }
45 std::shared_ptr<SubscribeInputActiveInfo> subscribeInfo = nullptr;
46 {
47 std::lock_guard<std::mutex> guard(mtx_);
48 if (subscribeInfo_) {
49 MMI_HILOGE("A process only supports one interface call");
50 return ERROR_ONE_PROCESS_ONLY_SUPPORT_ONE;
51 }
52 subscribeInfo = std::make_shared<SubscribeInputActiveInfo>(inputEventConsumer, interval);
53 CHKPR(subscribeInfo, ERROR_ALLOC_SUBSCRIBEINFO_FAILED);
54 }
55 int32_t ret = MULTIMODAL_INPUT_CONNECT_MGR->SubscribeInputActive(CURRENT_SUBSCRIBE_ID, interval);
56 if (ret != RET_OK) {
57 MMI_HILOGE("Subscribing input active failed, ret:%{public}d", ret);
58 return ERROR_SUBSCRIBE_SERVER_FAILED;
59 }
60 std::lock_guard<std::mutex> guard(mtx_);
61 if (subscribeInfo_) {
62 MMI_HILOGE("A process only supports one interface call");
63 return ERROR_ONE_PROCESS_ONLY_SUPPORT_ONE;
64 }
65 subscribeInfo_ = subscribeInfo;
66 MMI_HILOGI("The subscribeId:%{public}d, inputActiveInterval:%{public}" PRId64, CURRENT_SUBSCRIBE_ID, interval);
67 return CURRENT_SUBSCRIBE_ID;
68 }
69
UnsubscribeInputActive(int32_t subscribeId)70 int32_t InputActiveSubscribeManager::UnsubscribeInputActive(int32_t subscribeId)
71 {
72 CALL_INFO_TRACE;
73 CHKPR(MULTIMODAL_INPUT_CONNECT_MGR, RET_ERR);
74 if (subscribeId != CURRENT_SUBSCRIBE_ID) {
75 MMI_HILOGE("The subscribeId(%{public}d) is invalid", subscribeId);
76 return ERROR_INVALID_SUBSCRIBE_ID;
77 }
78
79 if (!MMIEventHdl.InitClient()) {
80 MMI_HILOGE("Client init failed");
81 return ERROR_INIT_CLIENT_FAILED;
82 }
83 {
84 std::lock_guard<std::mutex> guard(mtx_);
85 if (!subscribeInfo_) {
86 MMI_HILOGE("no SubscribeInputActive");
87 return ERROR_NO_SUBSCRIBE_INPUT_ACTIVE;
88 }
89 }
90 if (MULTIMODAL_INPUT_CONNECT_MGR->UnsubscribeInputActive(subscribeId) != RET_OK) {
91 MMI_HILOGE("Leave, unsubscribe input active failed");
92 return ERROR_UNSUBSCRIBE_SERVER_FAILED;
93 }
94 std::lock_guard<std::mutex> guard(mtx_);
95 subscribeInfo_ = nullptr;
96 return RET_OK;
97 }
98
OnSubscribeInputActiveCallback(std::shared_ptr<KeyEvent> keyEvent,int32_t subscribeId)99 int32_t InputActiveSubscribeManager::OnSubscribeInputActiveCallback(
100 std::shared_ptr<KeyEvent> keyEvent, int32_t subscribeId)
101 {
102 CHK_PID_AND_TID();
103 CHKPR(keyEvent, RET_ERR);
104 if (subscribeId != CURRENT_SUBSCRIBE_ID) {
105 MMI_HILOGE("The subscribeId(%{public}d) is invalid", subscribeId);
106 return ERROR_INVALID_SUBSCRIBE_ID;
107 }
108 std::shared_ptr<IInputEventConsumer> inputEventConsumer = nullptr;
109 {
110 std::lock_guard<std::mutex> guard(mtx_);
111 if (!subscribeInfo_) {
112 MMI_HILOGE("had UnsubscribeInputActive");
113 return ERROR_HAD_UNSUBSCRIBE_INPUT_ACTIVE;
114 }
115 inputEventConsumer = subscribeInfo_->GetCallback();
116 }
117 CHKPR(inputEventConsumer, RET_ERR);
118 inputEventConsumer->OnInputEvent(keyEvent);
119 MMI_HILOGD("subscribeId: %{public}d, keycode:%{private}d", subscribeId, keyEvent->GetKeyCode());
120 return RET_OK;
121 }
122
OnSubscribeInputActiveCallback(std::shared_ptr<PointerEvent> pointerEvent,int32_t subscribeId)123 int32_t InputActiveSubscribeManager::OnSubscribeInputActiveCallback(
124 std::shared_ptr<PointerEvent> pointerEvent, int32_t subscribeId)
125 {
126 CHK_PID_AND_TID();
127 CHKPR(pointerEvent, RET_ERR);
128 if (subscribeId != CURRENT_SUBSCRIBE_ID) {
129 MMI_HILOGE("The subscribeId(%{public}d) is invalid", subscribeId);
130 return ERROR_INVALID_SUBSCRIBE_ID;
131 }
132 std::shared_ptr<IInputEventConsumer> inputEventConsumer = nullptr;
133 {
134 std::lock_guard<std::mutex> guard(mtx_);
135 if (!subscribeInfo_) {
136 MMI_HILOGE("had UnsubscribeInputActive");
137 return ERROR_HAD_UNSUBSCRIBE_INPUT_ACTIVE;
138 }
139 inputEventConsumer = subscribeInfo_->GetCallback();
140 }
141 CHKPR(inputEventConsumer, RET_ERR);
142 inputEventConsumer->OnInputEvent(pointerEvent);
143 MMI_HILOGD("subscribeId: %{public}d, pointerId:%{private}d", subscribeId, pointerEvent->GetPointerId());
144 return RET_OK;
145 }
146
OnConnected()147 void InputActiveSubscribeManager::OnConnected()
148 {
149 CALL_DEBUG_ENTER;
150 CHKPV(MULTIMODAL_INPUT_CONNECT_MGR);
151 std::shared_ptr<SubscribeInputActiveInfo> subscribeInfo = nullptr;
152 {
153 std::lock_guard<std::mutex> guard(mtx_);
154 if (!subscribeInfo_) {
155 return;
156 }
157 subscribeInfo = subscribeInfo_;
158 }
159 int32_t ret = MULTIMODAL_INPUT_CONNECT_MGR->SubscribeInputActive(
160 CURRENT_SUBSCRIBE_ID, subscribeInfo->GetInputActiveInterval());
161 if (ret != RET_OK) {
162 MMI_HILOGE("SubscribeInputActive failed, subscribeId_:%{public}d, ret:%{public}d", CURRENT_SUBSCRIBE_ID, ret);
163 }
164 }
165 } // namespace MMI
166 } // namespace OHOS
167