1 /*
2 * Copyright (c) 2021-2022 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 "hisysevent_delegate.h"
17
18 #include "hilog/log.h"
19 #include "hisysevent_listener_proxy.h"
20 #include "hisysevent_query_proxy.h"
21 #include "if_system_ability_manager.h"
22 #include "ipc_skeleton.h"
23 #include "iservice_registry.h"
24 #include "query_argument.h"
25 #include "ret_code.h"
26 #include "sys_event_service_proxy.h"
27 #include "system_ability_definition.h"
28
29 using namespace std;
30
31 namespace OHOS {
32 namespace HiviewDFX {
33 static constexpr HiLogLabel LABEL = { LOG_CORE, 0xD002D08, "HiView-HiSysEventDelegate" };
34
AddListener(const std::shared_ptr<HiSysEventBaseListener> listener,const std::vector<ListenerRule> & rules)35 int32_t HiSysEventDelegate::AddListener(const std::shared_ptr<HiSysEventBaseListener> listener,
36 const std::vector<ListenerRule>& rules)
37 {
38 auto service = GetSysEventService();
39 if (service == nullptr) {
40 HiLog::Error(LABEL, "Fail to get service.");
41 return ERR_SYS_EVENT_SERVICE_NOT_FOUND;
42 }
43 std::vector<SysEventRule> eventRules;
44 ConvertListenerRule(rules, eventRules);
45
46 if (!spListenerCallBack) {
47 spListenerCallBack = new OHOS::HiviewDFX::HiSysEventListenerProxy(listener);
48 }
49
50 SysEventServiceProxy sysEventService(service);
51 service->RemoveDeathRecipient(spListenerCallBack->GetCallbackDeathRecipient());
52 return sysEventService.AddListener(eventRules, spListenerCallBack);
53 }
54
RemoveListener(const std::shared_ptr<HiSysEventBaseListener> listener)55 int32_t HiSysEventDelegate::RemoveListener(const std::shared_ptr<HiSysEventBaseListener> listener)
56 {
57 if (!spListenerCallBack) {
58 return ERR_LISTENER_NOT_EXIST;
59 }
60 auto service = GetSysEventService();
61 if (service == nullptr) {
62 HiLog::Error(LABEL, "Fail to get service.");
63 return ERR_SYS_EVENT_SERVICE_NOT_FOUND;
64 }
65 SysEventServiceProxy sysEventService(service);
66 return sysEventService.RemoveListener(spListenerCallBack);
67 }
68
SetDebugMode(const std::shared_ptr<HiSysEventBaseListener> listener,const bool mode)69 int32_t HiSysEventDelegate::SetDebugMode(const std::shared_ptr<HiSysEventBaseListener> listener,
70 const bool mode)
71 {
72 if (!spListenerCallBack) {
73 return ERR_LISTENER_NOT_EXIST;
74 }
75 auto service = GetSysEventService();
76 if (service == nullptr) {
77 HiLog::Error(LABEL, "Fail to get service.");
78 return ERR_SYS_EVENT_SERVICE_NOT_FOUND;
79 }
80 SysEventServiceProxy sysEventService(service);
81 return sysEventService.SetDebugMode(spListenerCallBack, mode);
82 }
83
Query(const struct QueryArg & arg,const std::vector<QueryRule> & rules,const std::shared_ptr<HiSysEventBaseQueryCallback> callback) const84 int32_t HiSysEventDelegate::Query(const struct QueryArg& arg,
85 const std::vector<QueryRule>& rules,
86 const std::shared_ptr<HiSysEventBaseQueryCallback> callback) const
87 {
88 auto service = GetSysEventService();
89 if (service == nullptr) {
90 HiLog::Error(LABEL, "Fail to get service.");
91 return ERR_SYS_EVENT_SERVICE_NOT_FOUND;
92 }
93
94 std::vector<SysEventQueryRule> hospRules;
95 ConvertQueryRule(rules, hospRules);
96
97 sptr<HiSysEventQueryProxy> spCallBack =
98 new OHOS::HiviewDFX::HiSysEventQueryProxy(callback);
99
100 SysEventServiceProxy sysEventService(service);
101 QueryArgument queryArgument(arg.beginTime, arg.endTime, arg.maxEvents, arg.fromSeq, arg.toSeq);
102 return sysEventService.Query(queryArgument, hospRules, spCallBack);
103 }
104
~HiSysEventDelegate()105 HiSysEventDelegate::~HiSysEventDelegate()
106 {
107 HiLog::Info(LABEL, "HiSysEventDelegate destructor");
108 }
109
ConvertListenerRule(const std::vector<ListenerRule> & rules,std::vector<SysEventRule> & sysRules) const110 void HiSysEventDelegate::ConvertListenerRule(const std::vector<ListenerRule>& rules,
111 std::vector<SysEventRule>& sysRules) const
112 {
113 for_each(rules.cbegin(), rules.cend(), [&sysRules](const ListenerRule& rule) {
114 if (rule.GetTag().empty()) {
115 sysRules.emplace_back(rule.GetDomain(), rule.GetEventName(), rule.GetRuleType(), rule.GetEventType());
116 } else {
117 sysRules.emplace_back(rule.GetTag(), rule.GetRuleType(), rule.GetEventType());
118 }
119 });
120 }
121
ConvertQueryRule(const std::vector<QueryRule> & rules,std::vector<SysEventQueryRule> & sysRules) const122 void HiSysEventDelegate::ConvertQueryRule(const std::vector<QueryRule>& rules,
123 std::vector<SysEventQueryRule>& sysRules) const
124 {
125 for_each(rules.cbegin(), rules.cend(), [&sysRules](const QueryRule &rule) {
126 std::vector<std::string> events;
127 auto eventList = rule.GetEventList();
128 for_each(eventList.cbegin(), eventList.cend(), [&](const std::string &event) {
129 events.push_back(event);
130 });
131 sysRules.emplace_back(rule.GetDomain(), events, rule.GetRuleType(), rule.GetEventType(), rule.GetCondition());
132 });
133 }
134
BinderFunc()135 void HiSysEventDelegate::BinderFunc()
136 {
137 IPCSkeleton::JoinWorkThread();
138 }
139
GetSysEventService() const140 sptr<IRemoteObject> HiSysEventDelegate::GetSysEventService() const
141 {
142 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
143 if (sam == nullptr) {
144 return nullptr;
145 }
146 return sam->CheckSystemAbility(DFX_SYS_EVENT_SERVICE_ABILITY_ID);
147 }
148 } // namespace HiviewDFX
149 } // namespace OHOS
150