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