1 /*
2 * Copyright (c) 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_manager_c.h"
17
18 #include <string>
19 #include <map>
20
21 #include "hisysevent_base_manager.h"
22 #include "hisysevent_listener_c.h"
23 #include "hisysevent_query_callback_c.h"
24 #include "ret_code.h"
25
26 namespace {
27 using OHOS::HiviewDFX::HiSysEventBaseManager;
28 using OHOS::HiviewDFX::HiSysEventBaseQueryCallback;
29 using QueryArgCls = OHOS::HiviewDFX::QueryArg;
30 using QueryRuleCls = OHOS::HiviewDFX::QueryRule;
31 using OHOS::HiviewDFX::RuleType::WHOLE_WORD;
32 using OHOS::HiviewDFX::ERR_QUERY_RULE_INVALID;
33 using ListenerRuleCls = OHOS::HiviewDFX::ListenerRule;
34 using OHOS::HiviewDFX::HiSysEventBaseListener;
35 using OHOS::HiviewDFX::IPC_CALL_SUCCEED;
36 using OHOS::HiviewDFX::ERR_LISTENER_NOT_EXIST;
37 using OHOS::HiviewDFX::RuleType;
38
39 static std::map<std::pair<OnEventFunc, OnServiceDiedFunc>, std::shared_ptr<HiSysEventBaseListener>> watchers;
40
HiSysEventQuery(const HiSysEventQueryArg & arg,HiSysEventQueryRule rules[],size_t ruleSize,HiSysEventQueryCallback & callback)41 int HiSysEventQuery(const HiSysEventQueryArg& arg, HiSysEventQueryRule rules[], size_t ruleSize,
42 HiSysEventQueryCallback& callback)
43 {
44 std::vector<QueryRuleCls> queryRules;
45 for (size_t i = 0; i < ruleSize; ++i) {
46 if (strlen(rules[i].domain) == 0 || rules[i].eventListSize == 0) {
47 return ERR_QUERY_RULE_INVALID;
48 }
49 std::vector<std::string> eventList;
50 for (size_t j = 0; j < rules[i].eventListSize; ++j) {
51 eventList.emplace_back(rules[i].eventList[j]);
52 }
53 std::string cond = rules[i].condition == nullptr ? "" : rules[i].condition;
54 queryRules.emplace_back(rules[i].domain, eventList, WHOLE_WORD, 0, cond);
55 }
56 QueryArgCls argCls(arg.beginTime, arg.endTime, arg.maxEvents);
57 auto callbackC = std::make_shared<HiSysEventQueryCallbackC>(callback.OnQuery, callback.OnComplete);
58 return HiSysEventBaseManager::Query(argCls, queryRules, std::make_shared<HiSysEventBaseQueryCallback>(callbackC));
59 }
60
HiSysEventAddWatcher(HiSysEventWatcher & watcher,HiSysEventWatchRule rules[],size_t ruleSize)61 int HiSysEventAddWatcher(HiSysEventWatcher& watcher, HiSysEventWatchRule rules[], size_t ruleSize)
62 {
63 std::vector<ListenerRuleCls> listenerRules;
64 for (size_t i = 0; i < ruleSize; ++i) {
65 listenerRules.emplace_back(rules[i].domain, rules[i].name, rules[i].tag, RuleType(rules[i].ruleType),
66 static_cast<uint32_t>(rules[i].eventType));
67 }
68 auto listenerC = std::make_shared<HiSysEventBaseListener>(
69 std::make_shared<HiSysEventListenerC>(watcher.OnEvent, watcher.OnServiceDied));
70 auto ret = HiSysEventBaseManager::AddListener(listenerC, listenerRules);
71 if (ret != IPC_CALL_SUCCEED) {
72 return ret;
73 }
74 watchers[std::make_pair(watcher.OnEvent, watcher.OnServiceDied)] = listenerC;
75 return ret;
76 }
77
HiSysEventRemoveWatcher(HiSysEventWatcher & watcher)78 int HiSysEventRemoveWatcher(HiSysEventWatcher& watcher)
79 {
80 auto watcherKey = std::make_pair(watcher.OnEvent, watcher.OnServiceDied);
81 auto watcherIter = watchers.find(watcherKey);
82 if (watcherIter == watchers.end()) {
83 return ERR_LISTENER_NOT_EXIST;
84 }
85 auto ret = HiSysEventBaseManager::RemoveListener(watcherIter->second);
86 if (ret == IPC_CALL_SUCCEED) {
87 watchers.erase(watcherIter->first);
88 }
89 return ret;
90 }
91 }
92
93 #ifdef __cplusplus
94 extern "C" {
95 #endif
96
OH_HiSysEvent_Query(const HiSysEventQueryArg * arg,HiSysEventQueryRule rules[],size_t ruleSize,HiSysEventQueryCallback * callback)97 int OH_HiSysEvent_Query(const HiSysEventQueryArg* arg, HiSysEventQueryRule rules[], size_t ruleSize,
98 HiSysEventQueryCallback* callback)
99 {
100 if (arg == nullptr) {
101 return OHOS::HiviewDFX::ERR_QUERY_ARG_NULL;
102 }
103 if (callback == nullptr || callback->OnQuery == nullptr || callback->OnComplete == nullptr) {
104 return OHOS::HiviewDFX::ERR_QUERY_CALLBACK_NULL;
105 }
106 return HiSysEventQuery(*arg, rules, ruleSize, *callback);
107 }
108
OH_HiSysEvent_Add_Watcher(HiSysEventWatcher * watcher,HiSysEventWatchRule rules[],size_t ruleSize)109 int OH_HiSysEvent_Add_Watcher(HiSysEventWatcher* watcher, HiSysEventWatchRule rules[], size_t ruleSize)
110 {
111 if (watcher == nullptr || watcher->OnEvent == nullptr || watcher->OnServiceDied == nullptr) {
112 return OHOS::HiviewDFX::ERR_LISTENER_NOT_EXIST;
113 }
114 return HiSysEventAddWatcher(*watcher, rules, ruleSize);
115 }
116
OH_HiSysEvent_Remove_Watcher(HiSysEventWatcher * watcher)117 int OH_HiSysEvent_Remove_Watcher(HiSysEventWatcher* watcher)
118 {
119 if (watcher == nullptr || watcher->OnEvent == nullptr || watcher->OnServiceDied == nullptr) {
120 return OHOS::HiviewDFX::ERR_LISTENER_NOT_EXIST;
121 }
122 return HiSysEventRemoveWatcher(*watcher);
123 }
124
125 #ifdef __cplusplus
126 }
127 #endif
128