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 <parameters.h>
17#include "switch_subscriber_handler.h"
18
19#include "bytrace_adapter.h"
20#include "define_multimodal.h"
21#include "dfx_hisysevent.h"
22#include "error_multimodal.h"
23#include "input_event_data_transformation.h"
24#include "input_event_handler.h"
25#include "net_packet.h"
26#include "proto.h"
27#include "util_ex.h"
28
29#undef MMI_LOG_DOMAIN
30#define MMI_LOG_DOMAIN MMI_LOG_HANDLER
31#undef MMI_LOG_TAG
32#define MMI_LOG_TAG "SwitchSubscriberHandler"
33
34namespace OHOS {
35namespace MMI {
36#ifdef OHOS_BUILD_ENABLE_KEYBOARD
37void SwitchSubscriberHandler::HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)
38{
39    CHKPV(keyEvent);
40    CHKPV(nextHandler_);
41    nextHandler_->HandleKeyEvent(keyEvent);
42}
43#endif // OHOS_BUILD_ENABLE_KEYBOARD
44
45#ifdef OHOS_BUILD_ENABLE_POINTER
46void SwitchSubscriberHandler::HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)
47{
48    CHKPV(pointerEvent);
49    CHKPV(nextHandler_);
50    nextHandler_->HandlePointerEvent(pointerEvent);
51}
52#endif // OHOS_BUILD_ENABLE_POINTER
53
54#ifdef OHOS_BUILD_ENABLE_TOUCH
55void SwitchSubscriberHandler::HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent)
56{
57    CHKPV(pointerEvent);
58    CHKPV(nextHandler_);
59    nextHandler_->HandleTouchEvent(pointerEvent);
60}
61#endif // OHOS_BUILD_ENABLE_TOUCH
62
63#ifdef OHOS_BUILD_ENABLE_SWITCH
64void SwitchSubscriberHandler::HandleSwitchEvent(const std::shared_ptr<SwitchEvent> switchEvent)
65{
66    CHKPV(switchEvent);
67    if (OnSubscribeSwitchEvent(switchEvent)) {
68        MMI_HILOGI("Subscribe switchEvent filter success. switchValue:%{public}d", switchEvent->GetSwitchValue());
69        return;
70    }
71    CHKPV(nextHandler_);
72    nextHandler_->HandleSwitchEvent(switchEvent);
73}
74#endif // OHOS_BUILD_ENABLE_SWITCH
75
76int32_t SwitchSubscriberHandler::SubscribeSwitchEvent(SessionPtr sess, int32_t subscribeId, int32_t switchType)
77{
78    CALL_INFO_TRACE;
79    if (subscribeId < 0) {
80        MMI_HILOGE("Invalid subscribeId");
81        return RET_ERR;
82    }
83    if (switchType < SwitchEvent::SwitchType::SWITCH_DEFAULT) {
84        MMI_HILOGE("Invalid switchType");
85        return RET_ERR;
86    }
87    CHKPR(sess, ERROR_NULL_POINTER);
88
89    MMI_HILOGD("subscribeId:%{public}d, switchType:%{public}d", subscribeId, switchType);
90    auto subscriber = std::make_shared<Subscriber>(subscribeId, sess, switchType);
91    InsertSubScriber(std::move(subscriber));
92    InitSessionDeleteCallback();
93    return RET_OK;
94}
95
96int32_t SwitchSubscriberHandler::UnsubscribeSwitchEvent(SessionPtr sess, int32_t subscribeId)
97{
98    CALL_INFO_TRACE;
99    MMI_HILOGD("subscribeId:%{public}d", subscribeId);
100    for (auto it = subscribers_.begin(); it != subscribers_.end(); ++it) {
101        if ((*it)->id_ == subscribeId && (*it)->sess_ == sess) {
102            subscribers_.erase(it);
103            return RET_OK;
104        }
105    }
106    MMI_HILOGE("UnsubscribeSwitchEvent failed with %{public}d", subscribeId);
107    return RET_ERR;
108}
109
110bool SwitchSubscriberHandler::OnSubscribeSwitchEvent(std::shared_ptr<SwitchEvent> switchEvent)
111{
112    CHKPF(switchEvent);
113    MMI_HILOGD("switchValue:%{public}d", switchEvent->GetSwitchValue());
114
115    if (switchEvent->GetSwitchType() == SwitchEvent::SwitchType::SWITCH_LID) {
116        DfxHisysevent::OnLidSwitchChanged(switchEvent->GetSwitchValue());
117    }
118
119    bool handled = false;
120    for (const auto &subscriber : subscribers_) {
121        if (subscriber->switchType_ == switchEvent->GetSwitchType() ||
122            (subscriber->switchType_ == SwitchEvent::SwitchType::SWITCH_DEFAULT &&
123                switchEvent->GetSwitchType() != SwitchEvent::SwitchType::SWITCH_PRIVACY)) {
124            NotifySubscriber(switchEvent, subscriber);
125            handled = true;
126        }
127    }
128    if (switchEvent->GetSwitchType() == SwitchEvent::SwitchType::SWITCH_PRIVACY) {
129        std::string value = OHOS::system::GetParameter(SUPER_PRIVACY_SWITCH, "");
130        if (value.empty() || value == "false") {
131            OHOS::system::SetParameter(SUPER_PRIVACY_SWITCH, "true");
132        } else {
133            OHOS::system::SetParameter(SUPER_PRIVACY_SWITCH, "false");
134        }
135    }
136    MMI_HILOGD("%{public}s", handled ? "true" : "false");
137    MMI_HILOGD("SUPER_PRIVACY_SWITCH: %{public}s", OHOS::system::GetParameter(SUPER_PRIVACY_SWITCH, "").c_str());
138    return handled;
139}
140
141void SwitchSubscriberHandler::InsertSubScriber(std::shared_ptr<Subscriber> subs)
142{
143    CALL_DEBUG_ENTER;
144    CHKPV(subs);
145    for (auto it = subscribers_.begin(); it != subscribers_.end(); ++it) {
146        if (subs->sess_ != nullptr && (*it)->id_ == subs->id_ && (*it)->sess_ == subs->sess_) {
147            MMI_HILOGW("Repeat registration id:%{public}d, desc:%{public}s",
148                subs->id_, subs->sess_->GetDescript().c_str());
149            return;
150        }
151    }
152    subscribers_.push_back(subs);
153}
154
155void SwitchSubscriberHandler::OnSessionDelete(SessionPtr sess)
156{
157    CALL_DEBUG_ENTER;
158    CHKPV(sess);
159    for (auto it = subscribers_.begin(); it != subscribers_.end();) {
160        if ((*it)->sess_ == sess) {
161            subscribers_.erase(it++);
162            continue;
163        }
164        ++it;
165    }
166}
167
168void SwitchSubscriberHandler::NotifySubscriber(std::shared_ptr<SwitchEvent> switchEvent,
169                                               const std::shared_ptr<Subscriber> &subscriber)
170{
171    CALL_DEBUG_ENTER;
172    CHKPV(switchEvent);
173    CHKPV(subscriber);
174    auto udsServerPtr = InputHandler->GetUDSServer();
175    CHKPV(udsServerPtr);
176    NetPacket pkt(MmiMessageId::ON_SUBSCRIBE_SWITCH);
177    InputEventDataTransformation::SwitchEventToNetPacket(switchEvent, pkt);
178    if (subscriber->sess_ == nullptr) {
179        MMI_HILOGE("Subscriber's sess is null");
180        return;
181    }
182    int32_t fd = subscriber->sess_->GetFd();
183    pkt << fd << subscriber->id_;
184    MMI_HILOGI("Notify subscriber id:%{public}d, switchValue:%{public}d, pid:%{public}d",
185        subscriber->id_, switchEvent->GetSwitchValue(), subscriber->sess_->GetPid());
186    if (pkt.ChkRWError()) {
187        MMI_HILOGE("Packet write dispatch subscriber failed");
188        return;
189    }
190    if (!udsServerPtr->SendMsg(fd, pkt)) {
191        MMI_HILOGE("Leave, server dispatch subscriber failed");
192    }
193}
194
195bool SwitchSubscriberHandler::InitSessionDeleteCallback()
196{
197    CALL_DEBUG_ENTER;
198    if (callbackInitialized_) {
199        MMI_HILOGD("Session delete callback has already been initialized");
200        return true;
201    }
202    auto udsServerPtr = InputHandler->GetUDSServer();
203    CHKPF(udsServerPtr);
204    std::function<void(SessionPtr)> callback =
205        [this] (SessionPtr sess) { return this->OnSessionDelete(sess); };
206    udsServerPtr->AddSessionDeletedCallback(callback);
207    callbackInitialized_ = true;
208    return true;
209}
210
211void SwitchSubscriberHandler::Dump(int32_t fd, const std::vector<std::string> &args)
212{
213    CALL_DEBUG_ENTER;
214    mprintf(fd, "Subscriber information:\t");
215    mprintf(fd, "subscribers: count=%zu", subscribers_.size());
216    for (const auto &item : subscribers_) {
217        std::shared_ptr<Subscriber> subscriber = item;
218        CHKPV(subscriber);
219        SessionPtr session = item->sess_;
220        CHKPV(session);
221        mprintf(fd, "subscriber id:%d | Pid:%d | Uid:%d | Fd:%d\t",
222                subscriber->id_, session->GetPid(), session->GetUid(), session->GetFd());
223    }
224}
225} // namespace MMI
226} // namespace OHOS
227