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