1 /*
2  * Copyright (c) 2021-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 #ifndef FOUNDATION_EVENT_CESFWK_SERVICES_INCLUDE_COMMON_EVENT_MANAGER_SERVICE_H
17 #define FOUNDATION_EVENT_CESFWK_SERVICES_INCLUDE_COMMON_EVENT_MANAGER_SERVICE_H
18 
19 #include "common_event_stub.h"
20 #include "event_handler.h"
21 #include "ffrt.h"
22 #include "inner_common_event_manager.h"
23 #include "nocopyable.h"
24 #include "refbase.h"
25 #include <mutex>
26 
27 namespace OHOS {
28 namespace EventFwk {
29 enum class ServiceRunningState { STATE_NOT_START, STATE_RUNNING };
30 
31 class CommonEventManagerService : public CommonEventStub {
32 public:
33     static sptr<CommonEventManagerService> GetInstance();
34     CommonEventManagerService();
35     virtual ~CommonEventManagerService();
36     /**
37      * Publishes a common event.
38      *
39      * @param event Indicates the common event data.
40      * @param publishInfo Indicates the publish info.
41      * @param commonEventListener Indicates the common event subscriber object.
42      * @param userId Indicates the user ID.
43      * @return Returns true if successful; false otherwise.
44      */
45     int32_t PublishCommonEvent(const CommonEventData &event, const CommonEventPublishInfo &publishinfo,
46         const sptr<IRemoteObject> &commonEventListener, const int32_t &userId) override;
47 
48     /**
49      * Publishes a common event.
50      *
51      * @param event Indicates the common event data.
52      * @param publishInfo Indicates the publish info.
53      * @param commonEventListener Indicates the common event subscriber.
54      * @param uid Indicates the uid of application.
55      * @param callerToken Indicates the caller token
56      * @param userId Indicates the user ID.
57      * @return Returns true if successful; false otherwise.
58      */
59     bool PublishCommonEvent(const CommonEventData &event, const CommonEventPublishInfo &publishinfo,
60         const sptr<IRemoteObject> &commonEventListener, const uid_t &uid, const int32_t &callerToken,
61         const int32_t &userId) override;
62 
63     /**
64      * Subscribes to common events.
65      *
66      * @param subscribeInfo Indicates the subscribe info.
67      * @param commonEventListener Indicates the common event subscriber.
68      * @param instanceKey Indicates the instance key
69      * @return Returns true if successful; false otherwise.
70      */
71     int32_t SubscribeCommonEvent(const CommonEventSubscribeInfo &subscribeInfo,
72         const sptr<IRemoteObject> &commonEventListener, const int32_t instanceKey = 0) override;
73 
74     /**
75      * Unsubscribes from common events.
76      *
77      * @param commonEventListener Indicates the common event subscriber.
78      * @return Returns true if successful; false otherwise.
79      */
80     int32_t UnsubscribeCommonEvent(const sptr<IRemoteObject> &commonEventListener) override;
81 
82     /**
83      * Gets the current sticky common event
84      *
85      * @param event Indicates the common event.
86      * @param eventData Indicates the common event data.
87      * @return Returns true if successful; false otherwise.
88      */
89     bool GetStickyCommonEvent(const std::string &event, CommonEventData &eventData) override;
90 
91     /**
92      * Dumps state of common event service.
93      *
94      * @param dumpType Indicates the dump type.
95      * @param event Specifies the information for the common event. Set null string ("") if you want to dump all.
96      * @param userId Indicates the user ID.
97      * @param state Indicates the state of common event service.
98      * @return Returns true if successful; false otherwise.
99      */
100     bool DumpState(const uint8_t &dumpType, const std::string &event, const int32_t &userId,
101         std::vector<std::string> &state) override;
102 
103     /**
104      * Finishes Receiver.
105      *
106      * @param proxy Indicates the receiver proxy.
107      * @param code Indicates the code of a common event.
108      * @param data Indicates the data of a common event.
109      * @param abortEvent Indicates Whether to cancel the current common event.
110      * @return Returns true if successful; false otherwise.
111      */
112     bool FinishReceiver(const sptr<IRemoteObject> &proxy, const int32_t &code, const std::string &receiverData,
113         const bool &abortEvent) override;
114 
115     /**
116      * Freezes application.
117      *
118      * @param uid Indicates the uid of application.
119      * @return Returns true if successful; false otherwise.
120      */
121     bool Freeze(const uid_t &uid) override;
122 
123     /**
124      * Unfreezes application.
125      *
126      * @param uid Indicates the Uid of application.
127      * @return Returns true if successful; false otherwise.
128      */
129     bool Unfreeze(const uid_t &uid) override;
130 
131     /**
132      * Unfreezes all frozen applications.
133      *
134      * @return Returns true if successful; false otherwise.
135      */
136     bool UnfreezeAll() override;
137 
138     /**
139      * Remove sticky common event.
140      *
141      * @param event Name of the common event.
142      * @return Returns ERR_OK if success; otherwise failed.
143      */
144     int32_t RemoveStickyCommonEvent(const std::string &event) override;
145 
146     /**
147      * Set Static Subscriber State.
148      *
149      * @param enable static subscriber state.
150      * @return Returns ERR_OK if success; otherwise failed.
151      */
152     int32_t SetStaticSubscriberState(bool enable) override;
153 
154     /**
155      * Set static subscriber state.
156      *
157      * @param events Static subscriber event name.
158      * @param enable Static subscriber state.
159      * @return Returns ERR_OK if success; otherwise failed.
160      */
161     int32_t SetStaticSubscriberState(const std::vector<std::string> &events, bool enable) override;
162 
163     /**
164     * Set freeze status of process.
165     *
166     * @param pidList Indicates the list of process id.
167     * @param isFreeze Indicates wheather the process is freezed.
168     * @return Returns true if successful; false otherwise.
169     */
170     bool SetFreezeStatus(std::set<int> pidList, bool isFreeze) override;
171 
172     int Dump(int fd, const std::vector<std::u16string> &args) override;
173 
174     ErrCode Init();
175 
176 private:
177     bool IsReady() const;
178 
179     int32_t PublishCommonEventDetailed(const CommonEventData &event, const CommonEventPublishInfo &publishinfo,
180         const sptr<IRemoteObject> &commonEventListener, const pid_t &pid, const uid_t &uid,
181         const int32_t &clientToken, const int32_t &userId);
182 
183     void GetHidumpInfo(const std::vector<std::u16string> &args, std::string &result);
184     int32_t CheckUserIdParams(const int32_t &userId);
185 private:
186     static sptr<CommonEventManagerService> instance_;
187     static std::mutex instanceMutex_;
188 
189     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager_;
190     ServiceRunningState serviceRunningState_ = ServiceRunningState::STATE_NOT_START;
191     std::shared_ptr<EventRunner> runner_;
192     std::shared_ptr<EventHandler> handler_;
193     std::shared_ptr<ffrt::queue> commonEventSrvQueue_ = nullptr;
194     std::string supportCheckSaPermission_ = "false";
195 
196     DISALLOW_COPY_AND_MOVE(CommonEventManagerService);
197 };
198 }  // namespace EventFwk
199 }  // namespace OHOS
200 
201 #endif  // FOUNDATION_EVENT_CESFWK_SERVICES_INCLUDE_COMMON_EVENT_MANAGER_SERVICE_H