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 "switch_event_input_subscribe_manager.h"
17
18 #include <cinttypes>
19
20 #include "bytrace_adapter.h"
21 #include "define_multimodal.h"
22 #include "error_multimodal.h"
23 #include "multimodal_event_handler.h"
24
25 #undef MMI_LOG_TAG
26 #define MMI_LOG_TAG "SwitchEventInputSubscribeManager"
27
28 namespace OHOS {
29 namespace MMI {
30 namespace {
31 constexpr int32_t INVALID_SUBSCRIBE_ID { -1 };
32 } // namespace
33 int32_t SwitchEventInputSubscribeManager::subscribeManagerId_ = 0;
34
SwitchEventInputSubscribeManager()35 SwitchEventInputSubscribeManager::SwitchEventInputSubscribeManager() {}
~SwitchEventInputSubscribeManager()36 SwitchEventInputSubscribeManager::~SwitchEventInputSubscribeManager() {}
37
SubscribeSwitchEventInfo(int32_t switchType,std::function<void (std::shared_ptr<SwitchEvent>)> callback)38 SwitchEventInputSubscribeManager::SubscribeSwitchEventInfo::SubscribeSwitchEventInfo(
39 int32_t switchType,
40 std::function<void(std::shared_ptr<SwitchEvent>)> callback)
41 : switchType_(switchType), callback_(callback)
42 {
43 }
44
SubscribeSwitchEvent(int32_t switchType,std::function<void (std::shared_ptr<SwitchEvent>)> callback)45 int32_t SwitchEventInputSubscribeManager::SubscribeSwitchEvent(
46 int32_t switchType,
47 std::function<void(std::shared_ptr<SwitchEvent>)> callback)
48 {
49 CALL_DEBUG_ENTER;
50 CHKPR(callback, ERROR_NULL_POINTER);
51 if (switchType < SwitchEvent::SwitchType::SWITCH_DEFAULT) {
52 MMI_HILOGE("Switch type error");
53 return RET_ERR;
54 }
55
56 std::lock_guard<std::mutex> guard(mtx_);
57 if (!MMIEventHdl.InitClient()) {
58 MMI_HILOGE("Client init failed");
59 return EVENT_REG_FAIL;
60 }
61 if (SwitchEventInputSubscribeManager::subscribeManagerId_ >= INT_MAX) {
62 MMI_HILOGE("The subscribeId has reached the upper limit, cannot continue the subscription");
63 return INVALID_SUBSCRIBE_ID;
64 }
65 int32_t subscribeId = SwitchEventInputSubscribeManager::subscribeManagerId_;
66 ++SwitchEventInputSubscribeManager::subscribeManagerId_;
67 subscribeInfos_.emplace(std::make_pair(subscribeId, SubscribeSwitchEventInfo(switchType, callback)));
68 int32_t ret = MMIEventHdl.SubscribeSwitchEvent(subscribeId, switchType);
69 if (ret != RET_OK) {
70 MMI_HILOGE("Subscribing switch event failed, ret:%{public}d", ret);
71 subscribeInfos_.erase(subscribeId);
72 return INVALID_SUBSCRIBE_ID;
73 }
74 MMI_HILOGI("subscribeId:%{public}d, switchType:%{public}d", subscribeId, switchType);
75
76 return subscribeId;
77 }
78
UnsubscribeSwitchEvent(int32_t subscribeId)79 int32_t SwitchEventInputSubscribeManager::UnsubscribeSwitchEvent(int32_t subscribeId)
80 {
81 CALL_INFO_TRACE;
82 if (subscribeId < 0) {
83 MMI_HILOGE("The subscribe id is less than 0");
84 return RET_ERR;
85 }
86
87 std::lock_guard<std::mutex> guard(mtx_);
88 if (!MMIEventHdl.InitClient()) {
89 MMI_HILOGE("Client init failed");
90 return INVALID_SUBSCRIBE_ID;
91 }
92 if (subscribeInfos_.empty()) {
93 MMI_HILOGE("The subscribeInfos is empty");
94 return RET_ERR;
95 }
96
97 auto it = subscribeInfos_.find(subscribeId);
98 if (it != subscribeInfos_.end()) {
99 if (MMIEventHdl.UnsubscribeSwitchEvent(subscribeId) != RET_OK) {
100 MMI_HILOGE("Leave, unsubscribe switch event failed");
101 return RET_ERR;
102 }
103 subscribeInfos_.erase(it);
104 return RET_OK;
105 }
106
107 return RET_ERR;
108 }
109
OnSubscribeSwitchEventCallback(std::shared_ptr<SwitchEvent> event,int32_t subscribeId)110 int32_t SwitchEventInputSubscribeManager::OnSubscribeSwitchEventCallback(std::shared_ptr<SwitchEvent> event,
111 int32_t subscribeId)
112 {
113 CHK_PID_AND_TID();
114 CHKPR(event, ERROR_NULL_POINTER);
115 if (subscribeId < 0) {
116 MMI_HILOGE("Leave, the subscribe id is less than 0");
117 return RET_ERR;
118 }
119 std::function<void(std::shared_ptr<SwitchEvent>)> callback = nullptr;
120 std::lock_guard<std::mutex> guard(mtx_);
121 auto it = subscribeInfos_.find(subscribeId);
122 if (it != subscribeInfos_.end()) {
123 SubscribeSwitchEventInfo &subscribeInfo = it->second;
124 callback = subscribeInfo.GetCallback();
125 }
126 CHKPR(callback, ERROR_NULL_POINTER);
127 callback(event);
128 MMI_HILOGI("Switch event id:%{public}d, switchValue:%{public}d", subscribeId, event->GetSwitchValue());
129 return RET_OK;
130 }
131
OnConnected()132 void SwitchEventInputSubscribeManager::OnConnected()
133 {
134 CALL_DEBUG_ENTER;
135 if (subscribeInfos_.empty()) {
136 MMI_HILOGD("Leave, subscribeInfos_ is empty");
137 return;
138 }
139 for (auto it = subscribeInfos_.begin(); it != subscribeInfos_.end(); ++it) {
140 SubscribeSwitchEventInfo &subscribeInfo = it->second;
141 int32_t ret = MMIEventHdl.SubscribeSwitchEvent(subscribeInfo.GetSwitchType(), it->first);
142 if (ret != RET_OK) {
143 MMI_HILOGE("Subscribe switch event failed, ret:%{public}d", ret);
144 }
145 }
146 }
147 } // namespace MMI
148 } // namespace OHOS
149