1 /*
2  * Copyright (c) 2023 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 <cinttypes>
17 
18 #include "common_event_collect.h"
19 
20 #include "ability_death_recipient.h"
21 #include "system_ability_manager_util.h"
22 #include "common_event_manager.h"
23 #include "common_event_support.h"
24 #include "matching_skills.h"
25 #include "parse_util.h"
26 #include "want.h"
27 #include "sam_log.h"
28 #include "sa_profiles.h"
29 #include "system_ability_manager.h"
30 #include "samgr_xcollie.h"
31 
32 using namespace OHOS::AppExecFwk;
33 namespace OHOS {
34 namespace {
35 constexpr uint32_t INIT_EVENT = 10;
36 constexpr uint32_t SUB_COMMON_EVENT = 11;
37 constexpr uint32_t REMOVE_EXTRA_DATA_EVENT = 12;
38 constexpr uint32_t REMOVE_EXTRA_DATA_DELAY_TIME = 300000;
39 constexpr uint32_t UNSUB_DELAY_TIME = 10 * 1000;
40 constexpr int64_t MAX_EXTRA_DATA_ID = 1000000000;
41 constexpr int32_t COMMON_EVENT_SERVICE_ID = 3299;
42 constexpr const char* UID = "uid";
43 constexpr const char* NET_TYPE = "NetType";
44 constexpr const char* BUNDLE_NAME = "bundleName";
45 constexpr const char* COMMON_EVENT_ACTION_NAME = "common_event_action_name";
46 }
47 
CommonEventCollect(const sptr<IReport> & report)48 CommonEventCollect::CommonEventCollect(const sptr<IReport>& report)
49     : ICollectPlugin(report)
50 {
51 }
52 
RemoveWhiteCommonEvent()53 void CommonEventCollect::RemoveWhiteCommonEvent()
54 {
55     std::lock_guard<std::mutex> autoLock(commonEventStateLock_);
56     commonEventWhitelist.erase(EventFwk::CommonEventSupport::COMMON_EVENT_USER_UNLOCKED);
57     HILOGI("rm USER_UNLOCKED,size=%{public}zu", commonEventWhitelist.size());
58 }
59 
CleanFfrt()60 void CommonEventCollect::CleanFfrt()
61 {
62     if (workHandler_ != nullptr) {
63         workHandler_->CleanFfrt();
64     }
65     if (unsubHandler_ != nullptr) {
66         unsubHandler_->CleanFfrt();
67     }
68 }
69 
SetFfrt()70 void CommonEventCollect::SetFfrt()
71 {
72     if (workHandler_ != nullptr) {
73         workHandler_->SetFfrt();
74     }
75     if (unsubHandler_ != nullptr) {
76         unsubHandler_->SetFfrt();
77     }
78 }
79 
OnStart()80 int32_t CommonEventCollect::OnStart()
81 {
82     HILOGI("CommonEventCollect OnStart called");
83     if (commonEventNames_.empty()) {
84         HILOGW("CommonEventCollect commonEventNames_ is empty");
85         return ERR_OK;
86     }
87 
88     workHandler_ = std::make_shared<CommonHandler>(this);
89     unsubHandler_ = std::make_shared<CommonHandler>(this);
90     workHandler_->SendEvent(INIT_EVENT);
91     return ERR_OK;
92 }
93 
OnStop()94 int32_t CommonEventCollect::OnStop()
95 {
96     if (workHandler_ != nullptr) {
97         workHandler_ = nullptr;
98     }
99     if (unsubHandler_ != nullptr) {
100         unsubHandler_ = nullptr;
101     }
102     return ERR_OK;
103 }
104 
InitCommonEventState(const OnDemandEvent & event)105 void CommonEventCollect::InitCommonEventState(const OnDemandEvent& event)
106 {
107     if (event.eventId == COMMON_EVENT) {
108         std::lock_guard<std::mutex> autoLock(commomEventLock_);
109         commonEventNames_.insert(event.name);
110         for (auto [key, value] : event.extraMessages) {
111             extraDataKey_[event.name].insert(key);
112         }
113     }
114     for (auto& condition : event.conditions) {
115         if (condition.eventId != COMMON_EVENT) {
116             continue;
117         }
118         {
119             std::lock_guard<std::mutex> autoLock(commomEventLock_);
120             commonEventNames_.insert(condition.name);
121         }
122         if (condition.extraMessages.size() > 0) {
123             std::lock_guard<std::mutex> autoLock(commonEventStateLock_);
124             for (auto [key, value] : condition.extraMessages) {
125                 commonEventConditionExtraData_[condition.name][key] = "";
126             }
127         }
128     }
129 }
130 
Init(const std::list<SaProfile> & onDemandSaProfiles)131 void CommonEventCollect::Init(const std::list<SaProfile>& onDemandSaProfiles)
132 {
133     {
134         std::lock_guard<std::mutex> autoLock(commonEventStateLock_);
135         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
136         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING);
137         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED);
138     }
139     {
140         std::lock_guard<std::mutex> autoLock(commomEventLock_);
141         commonEventNames_.insert(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
142         commonEventNames_.insert(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
143         commonEventNames_.insert(EventFwk::CommonEventSupport::COMMON_EVENT_CHARGING);
144         commonEventNames_.insert(EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING);
145         commonEventNames_.insert(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
146         commonEventNames_.insert(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED);
147         commonEventNames_.insert(EventFwk::CommonEventSupport::COMMON_EVENT_USER_UNLOCKED);
148     }
149 
150     for (auto& profile : onDemandSaProfiles) {
151         for (auto iterStart = profile.startOnDemand.onDemandEvents.begin();
152             iterStart != profile.startOnDemand.onDemandEvents.end(); iterStart++) {
153             InitCommonEventState(*iterStart);
154         }
155         for (auto iterStop = profile.stopOnDemand.onDemandEvents.begin();
156             iterStop != profile.stopOnDemand.onDemandEvents.end(); iterStop++) {
157             InitCommonEventState(*iterStop);
158         }
159     }
160 }
161 
AddSkillsEvent(EventFwk::MatchingSkills & skill)162 void CommonEventCollect::AddSkillsEvent(EventFwk::MatchingSkills& skill)
163 {
164     std::lock_guard<std::mutex> autoLock(commomEventLock_);
165     for (auto& commonEventName : commonEventNames_) {
166         HILOGD("CommonEventCollect add event: %{public}s", commonEventName.c_str());
167         skill.AddEvent(commonEventName);
168     }
169 }
170 
CleanFailedEventLocked(const std::string & eventName)171 void CommonEventCollect::CleanFailedEventLocked(const std::string& eventName)
172 {
173     if (commonEventSubscriber_ == nullptr) {
174         HILOGE("commonEventSubscriber_ is nullptr!");
175         return;
176     }
177     EventFwk::MatchingSkills skill = commonEventSubscriber_->GetSubscribeInfo().GetMatchingSkills();
178     skill.RemoveEvent(eventName);
179     std::lock_guard<std::mutex> autoLock(commomEventLock_);
180     commonEventNames_.erase(eventName);
181 }
182 
CreateCommonEventSubscriber()183 bool CommonEventCollect::CreateCommonEventSubscriber()
184 {
185     std::lock_guard<std::mutex> autoLock(commonEventSubscriberLock_);
186     return CreateCommonEventSubscriberLocked();
187 }
188 
CreateCommonEventSubscriberLocked()189 bool CommonEventCollect::CreateCommonEventSubscriberLocked()
190 {
191     int64_t begin = GetTickCount();
192     EventFwk::MatchingSkills skill = EventFwk::MatchingSkills();
193     AddSkillsEvent(skill);
194     EventFwk::CommonEventSubscribeInfo info(skill);
195     std::shared_ptr<EventFwk::CommonEventSubscriber> comEvtScrb = commonEventSubscriber_;
196     commonEventSubscriber_ = std::make_shared<CommonEventSubscriber>(info, this);
197     bool ret = EventFwk::CommonEventManager::SubscribeCommonEvent(commonEventSubscriber_);
198     HILOGI("SubsComEvt %{public}" PRId64 "ms %{public}s", (GetTickCount() - begin), ret ? "suc" : "fail");
199     if (comEvtScrb != nullptr) {
200         auto unsubTask = [comEvtScrb]() {
201             HILOGI("UnSubsComEvt start");
202             {
203                 SamgrXCollie samgrXCollie("samgr--UnSubscribeCommonEvent");
204                 bool isUnsubscribe = EventFwk::CommonEventManager::UnSubscribeCommonEvent(comEvtScrb);
205                 if (!isUnsubscribe) {
206                     HILOGE("CreateCommonEventSubscriberLocked isUnsubscribe failed!");
207                 }
208             }
209         };
210         if (unsubHandler_ != nullptr) {
211             unsubHandler_->PostTask(unsubTask, UNSUB_DELAY_TIME);
212         } else {
213             HILOGE("CreateCommonEventSubscriberLocked unsubHandler is null!");
214         }
215     }
216     return ret;
217 }
218 
SendEvent(uint32_t eventId)219 bool CommonEventCollect::SendEvent(uint32_t eventId)
220 {
221     if (workHandler_ == nullptr) {
222         HILOGI("CommonEventCollect workHandler is nullptr");
223         return false;
224     }
225     return workHandler_->SendEvent(eventId);
226 }
227 
CommonEventListener(const sptr<CommonEventCollect> & commonEventCollect)228 CommonEventListener::CommonEventListener(const sptr<CommonEventCollect>& commonEventCollect)
229     : commonEventCollect_(commonEventCollect) {}
230 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)231 void CommonEventListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
232 {
233     if (commonEventCollect_ == nullptr) {
234         HILOGE("commonEventCollect_ is nullptr!");
235         return;
236     }
237     if (systemAbilityId == COMMON_EVENT_SERVICE_ID) {
238         HILOGI("CommonEventCollect ces is ready");
239         commonEventCollect_->SendEvent(SUB_COMMON_EVENT);
240     }
241 }
242 
OnRemoveSystemAbility(int32_t systemAblityId,const std::string & deviceId)243 void CommonEventListener::OnRemoveSystemAbility(int32_t systemAblityId, const std::string& deviceId)
244 {
245     HILOGI("CommonEventListener OnRemoveSystemAblity systemAblityId:%{public}d", systemAblityId);
246 }
247 
SaveAction(const std::string & action)248 void CommonEventCollect::SaveAction(const std::string& action)
249 {
250     std::lock_guard<std::mutex> autoLock(commonEventStateLock_);
251     if (action == EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON) {
252         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
253         commonEventWhitelist.erase(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
254     } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF) {
255         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
256         commonEventWhitelist.erase(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
257     } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_CHARGING) {
258         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_CHARGING);
259         commonEventWhitelist.erase(EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING);
260     } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING) {
261         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING);
262         commonEventWhitelist.erase(EventFwk::CommonEventSupport::COMMON_EVENT_CHARGING);
263     } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED) {
264         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
265         commonEventWhitelist.erase(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED);
266     } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED) {
267         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED);
268         commonEventWhitelist.erase(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
269     } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_USER_UNLOCKED) {
270         commonEventWhitelist.insert(EventFwk::CommonEventSupport::COMMON_EVENT_USER_UNLOCKED);
271     }
272 }
273 
CheckCondition(const OnDemandCondition & condition)274 bool CommonEventCollect::CheckCondition(const OnDemandCondition& condition)
275 {
276     std::lock_guard<std::mutex> autoLock(commonEventStateLock_);
277     std::map<std::string, std::string> stateMap = commonEventConditionExtraData_[condition.name];
278     for (auto [key, profileValue] : condition.extraMessages) {
279         if (!ParseUtil::CheckLogicRelationship(stateMap[key], profileValue)) {
280             return false;
281         }
282     }
283     if (commonEventConditionValue_[condition.name] != condition.value && condition.value != "") {
284         return false;
285     }
286     if (condition.name == EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON ||
287         condition.name == EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF ||
288         condition.name == EventFwk::CommonEventSupport::COMMON_EVENT_CHARGING ||
289         condition.name == EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING ||
290         condition.name == EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED ||
291         condition.name == EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED ||
292         condition.name == EventFwk::CommonEventSupport::COMMON_EVENT_USER_UNLOCKED) {
293         return commonEventWhitelist.count(condition.name) > 0;
294     }
295     return true;
296 }
297 
CheckExtraMessage(int64_t extraDataId,const OnDemandEvent & profileEvent)298 bool CommonEventCollect::CheckExtraMessage(int64_t extraDataId, const OnDemandEvent& profileEvent)
299 {
300     OnDemandReasonExtraData extraData;
301     if (!GetOnDemandReasonExtraData(extraDataId, extraData)) {
302         return false;
303     }
304     std::map<std::string, std::string> eventExtraMessages = extraData.GetWant();
305     for (auto [key, profileValue] : profileEvent.extraMessages) {
306         if (!ParseUtil::CheckLogicRelationship(eventExtraMessages[key], profileValue)) {
307             return false;
308         }
309     }
310     return true;
311 }
312 
GenerateExtraDataIdLocked()313 int64_t CommonEventCollect::GenerateExtraDataIdLocked()
314 {
315     extraDataId_++;
316     if (extraDataId_ > MAX_EXTRA_DATA_ID) {
317         extraDataId_ = 1;
318     }
319     return extraDataId_;
320 }
321 
GetParamFromWant(const std::string & key,const AAFwk::Want & want)322 std::string CommonEventCollect::GetParamFromWant(const std::string& key, const AAFwk::Want& want)
323 {
324     std::string valueString;
325     int32_t valueInt = want.GetIntParam(key, -1);
326     if (valueInt == -1) {
327         valueString = want.GetStringParam(key);
328     } else {
329         valueString = std::to_string(valueInt);
330     }
331     if (want.GetBoolParam(key, false)) {
332         valueString = "true";
333     } else if (!want.GetBoolParam(key, true)) {
334         valueString = "false";
335     }
336     HILOGD("key:%{public}s || value:%{public}s", key.c_str(), valueString.c_str());
337     return valueString;
338 }
339 
SaveOnDemandReasonExtraData(const EventFwk::CommonEventData & data)340 int64_t CommonEventCollect::SaveOnDemandReasonExtraData(const EventFwk::CommonEventData& data)
341 {
342     HILOGD("CommonEventCollect extraData code: %{public}d, data: %{public}s", data.GetCode(),
343         data.GetData().c_str());
344     AAFwk::Want want = data.GetWant();
345     auto keySet = want.GetParams().KeySet();
346     std::map<std::string, std::string> wantMap;
347     for (const auto& key : keySet) {
348         wantMap[key] = GetParamFromWant(key, want);
349         HILOGD("CommonEventCollect want key:%{public}s, val:%{public}s", key.c_str(), wantMap[key].c_str());
350     }
351     int32_t uid = want.GetIntParam(UID, -1);
352     int32_t netType = want.GetIntParam(NET_TYPE, -1);
353     wantMap[UID] = std::to_string(uid);
354     wantMap[NET_TYPE] = std::to_string(netType);
355     wantMap[BUNDLE_NAME] = want.GetBundle();
356     std::lock_guard<std::mutex> autoLock(extraDataLock_);
357     for (auto key : extraDataKey_[want.GetAction()]) {
358         wantMap[key] = GetParamFromWant(key, want);
359     }
360     wantMap[COMMON_EVENT_ACTION_NAME] = want.GetAction();
361     OnDemandReasonExtraData extraData(data.GetCode(), data.GetData(), wantMap);
362 
363     int64_t extraDataId = GenerateExtraDataIdLocked();
364     extraDatas_[extraDataId] = extraData;
365     HILOGD("CommonEventCollect save extraData %{public}d", static_cast<int32_t>(extraDataId));
366     if (workHandler_ == nullptr) {
367         HILOGI("CommonEventCollect workHandler is nullptr");
368         return -1;
369     }
370     workHandler_->SendEvent(REMOVE_EXTRA_DATA_EVENT, extraDataId, REMOVE_EXTRA_DATA_DELAY_TIME);
371     return extraDataId;
372 }
373 
SaveOnDemandConditionExtraData(const EventFwk::CommonEventData & data)374 void CommonEventCollect::SaveOnDemandConditionExtraData(const EventFwk::CommonEventData& data)
375 {
376     std::lock_guard<std::mutex> autoLock(commonEventStateLock_);
377     AAFwk::Want want = data.GetWant();
378     commonEventConditionValue_[want.GetAction()] = std::to_string(data.GetCode());
379     for (auto& [key, value] : commonEventConditionExtraData_[want.GetAction()]) {
380         value = GetParamFromWant(key, want);
381     }
382 }
383 
RemoveOnDemandReasonExtraData(int64_t extraDataId)384 void CommonEventCollect::RemoveOnDemandReasonExtraData(int64_t extraDataId)
385 {
386     {
387         std::lock_guard<std::mutex> autoLock(extraDataLock_);
388         extraDatas_.erase(extraDataId);
389     }
390     HILOGD("CommonEventCollect remove extraData %{public}d", static_cast<int32_t>(extraDataId));
391     RemoveSaExtraDataId(extraDataId);
392 }
393 
GetOnDemandReasonExtraData(int64_t extraDataId,OnDemandReasonExtraData & extraData)394 bool CommonEventCollect::GetOnDemandReasonExtraData(int64_t extraDataId, OnDemandReasonExtraData& extraData)
395 {
396     std::lock_guard<std::mutex> autoLock(extraDataLock_);
397     HILOGD("CommonEventCollect get extraData %{public}d", static_cast<int32_t>(extraDataId));
398     if (extraDatas_.count(extraDataId) == 0) {
399         return false;
400     }
401     extraData = extraDatas_[extraDataId];
402     return true;
403 }
404 
SaveCacheCommonEventSaExtraId(const OnDemandEvent & event,const std::list<SaControlInfo> & saControlList)405 void CommonEventCollect::SaveCacheCommonEventSaExtraId(const OnDemandEvent& event,
406     const std::list<SaControlInfo>& saControlList)
407 {
408     std::list<int32_t> saList = SamgrUtil::GetCacheCommonEventSa(event, saControlList);
409     if (saList.empty()) {
410         return;
411     }
412     for (auto& item : saList) {
413         SaveSaExtraDataId(item, event.extraDataId);
414     }
415 }
416 
SaveSaExtraDataId(int32_t saId,int64_t extraDataId)417 void CommonEventCollect::SaveSaExtraDataId(int32_t saId, int64_t extraDataId)
418 {
419     std::lock_guard<std::mutex> autoLock(saExtraDataIdLock_);
420     auto& extraIdList = saExtraDataIdMap_[saId];
421     extraIdList.emplace_back(extraDataId);
422     HILOGI("save SA:%{public}d,exId:%{public}d,n:%{public}zu", saId, static_cast<int32_t>(extraDataId),
423         extraIdList.size());
424 }
425 
RemoveSaExtraDataId(int64_t extraDataId)426 void CommonEventCollect::RemoveSaExtraDataId(int64_t extraDataId)
427 {
428     std::lock_guard<std::mutex> autoLock(saExtraDataIdLock_);
429     HILOGD("rm saExtraId:%{public}d", static_cast<int32_t>(extraDataId));
430     auto iter = saExtraDataIdMap_.begin();
431     while (iter != saExtraDataIdMap_.end()) {
432         auto& tmpList = iter->second;
433         auto listIter = std::find(tmpList.begin(), tmpList.end(), extraDataId);
434         if (listIter != tmpList.end()) {
435             HILOGI("rm SA:%{public}d,exId:%{public}d,n:%{public}zu", iter->first,
436                 static_cast<int32_t>(extraDataId), tmpList.size());
437             tmpList.erase(listIter);
438         }
439         if (tmpList.size() == 0) {
440             HILOGI("rm exId SA:%{public}d", iter->first);
441             iter = saExtraDataIdMap_.erase(iter);
442         } else {
443             ++iter;
444         }
445     }
446 }
447 
ClearSaExtraDataId(int32_t saId)448 void CommonEventCollect::ClearSaExtraDataId(int32_t saId)
449 {
450     std::lock_guard<std::mutex> autoLock(saExtraDataIdLock_);
451     if (saExtraDataIdMap_.count(saId) == 0) {
452         return;
453     }
454     HILOGI("clear SA:%{public}d,map n:%{public}zu", saId, saExtraDataIdMap_.size());
455     saExtraDataIdMap_[saId].clear();
456     saExtraDataIdMap_.erase(saId);
457 }
458 
GetSaExtraDataIdList(int32_t saId,std::vector<int64_t> & extraDataidList,const std::string & eventName)459 int32_t CommonEventCollect::GetSaExtraDataIdList(int32_t saId, std::vector<int64_t>& extraDataidList,
460     const std::string& eventName)
461 {
462     std::list<int64_t> temp;
463     {
464         std::lock_guard<std::mutex> autoLock(saExtraDataIdLock_);
465         if (saExtraDataIdMap_.count(saId) == 0) {
466             HILOGD("NF exId SA:%{public}d", saId);
467             return ERR_OK;
468         }
469         HILOGD("get exId SA:%{public}d event:%{public}s", saId, eventName.c_str());
470         temp = saExtraDataIdMap_[saId];
471     }
472     if (eventName == "") {
473         std::copy(temp.begin(), temp.end(), std::back_inserter(extraDataidList));
474         return ERR_OK;
475     }
476     for (auto& item : temp) {
477         OnDemandReasonExtraData extraData;
478         if (!GetOnDemandReasonExtraData(item, extraData)) {
479             HILOGD("NF exId:%{public}d", static_cast<int32_t>(item));
480             continue;
481         }
482         std::map<std::string, std::string> want = extraData.GetWant();
483         std::string extraEventName = want[COMMON_EVENT_ACTION_NAME];
484         if (extraEventName != eventName) {
485             HILOGD("exId:%{public}d event:%{public}s not match extra:%{public}s", static_cast<int32_t>(item),
486                 eventName.c_str(), extraEventName.c_str());
487             continue;
488         }
489         HILOGD("get exId:%{public}d", static_cast<int32_t>(item));
490         extraDataidList.push_back(item);
491     }
492     return ERR_OK;
493 }
494 
AddCommonEventName(const std::string & eventName)495 bool CommonEventCollect::AddCommonEventName(const std::string& eventName)
496 {
497     std::lock_guard<std::mutex> autoLock(commomEventLock_);
498     auto iter = commonEventNames_.find(eventName);
499     if (iter != commonEventNames_.end()) {
500         return false;
501     }
502     HILOGI("CommonEventCollect add collect events: %{public}s", eventName.c_str());
503     commonEventNames_.insert(eventName);
504     return true;
505 }
506 
AddCollectEvent(const OnDemandEvent & event)507 int32_t CommonEventCollect::AddCollectEvent(const OnDemandEvent& event)
508 {
509     std::lock_guard<std::mutex> autoLock(commonEventSubscriberLock_);
510     bool isInsertEventName = AddCommonEventName(event.name);
511     if (!CreateCommonEventSubscriberLocked()) {
512         if (isInsertEventName) {
513             CleanFailedEventLocked(event.name);
514             CreateCommonEventSubscriberLocked();
515         }
516         HILOGE("AddCollectEvent CreateCommonEventSubscriber failed!");
517         return ERR_INVALID_VALUE;
518     }
519     return ERR_OK;
520 }
521 
RemoveUnusedEvent(const OnDemandEvent & event)522 int32_t CommonEventCollect::RemoveUnusedEvent(const OnDemandEvent& event)
523 {
524     std::lock_guard<std::mutex> autoLock(commomEventLock_);
525     auto iter = commonEventNames_.find(event.name);
526     if (iter != commonEventNames_.end()) {
527         HILOGI("CommonEventCollect remove event name: %{public}s", event.name.c_str());
528         commonEventNames_.erase(iter);
529     }
530     return ERR_OK;
531 }
532 
PostTask(std::function<void ()> func,uint64_t delayTime)533 bool CommonHandler::PostTask(std::function<void()> func, uint64_t delayTime)
534 {
535     if (handler_ == nullptr) {
536         HILOGE("CommonEventCollect PostTask handler is null!");
537         return false;
538     }
539     return handler_->PostTask(func, delayTime);
540 }
CleanFfrt()541 void CommonHandler::CleanFfrt()
542 {
543     if (handler_ != nullptr) {
544         handler_->CleanFfrt();
545     }
546 }
547 
SetFfrt()548 void CommonHandler::SetFfrt()
549 {
550     if (handler_ != nullptr) {
551         handler_->SetFfrt("CommonHandler");
552     }
553 }
554 
ProcessEvent(uint32_t eventId,int64_t extraDataId)555 void CommonHandler::ProcessEvent(uint32_t eventId, int64_t extraDataId)
556 {
557     if (commonCollect_ == nullptr) {
558         HILOGE("CommonEventCollect ProcessEvent collect or event is null!");
559         return;
560     }
561     if (eventId != INIT_EVENT && eventId != REMOVE_EXTRA_DATA_EVENT && eventId != SUB_COMMON_EVENT) {
562         HILOGE("CommonEventCollect ProcessEvent error event code!");
563         return;
564     }
565     auto commonCollect = commonCollect_.promote();
566     if (commonCollect == nullptr) {
567         HILOGE("CommonEventCollect collect is nullptr");
568         return;
569     }
570     if (eventId == REMOVE_EXTRA_DATA_EVENT) {
571         commonCollect->RemoveOnDemandReasonExtraData(extraDataId);
572         return;
573     }
574     if (eventId == SUB_COMMON_EVENT) {
575         if (!commonCollect->CreateCommonEventSubscriber()) {
576             HILOGE("OnAddSystemAbility CreateCommonEventSubscriber failed!");
577         }
578         return;
579     }
580     sptr<CommonEventListener> listener = new CommonEventListener(commonCollect);
581     SystemAbilityManager::GetInstance()->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, listener);
582 }
583 
SendEvent(uint32_t eventId)584 bool CommonHandler::SendEvent(uint32_t eventId)
585 {
586     if (handler_ == nullptr) {
587         HILOGE("CommonEventCollect SendEvent handler is null!");
588         return false;
589     }
590     auto task = [this, eventId] {this->ProcessEvent(eventId, 0);};
591     return handler_->PostTask(task);
592 }
593 
SendEvent(uint32_t eventId,int64_t extraDataId,uint64_t delayTime)594 bool CommonHandler::SendEvent(uint32_t eventId, int64_t extraDataId, uint64_t delayTime)
595 {
596     if (handler_ == nullptr) {
597         HILOGE("CommonEventCollect SendEvent handler is null!");
598         return false;
599     }
600     auto task = [this, eventId, extraDataId] {this->ProcessEvent(eventId, extraDataId);};
601     return handler_->PostTask(task, delayTime);
602 }
603 
CommonEventSubscriber(const EventFwk::CommonEventSubscribeInfo & subscribeInfo,const sptr<CommonEventCollect> & collect)604 CommonEventSubscriber::CommonEventSubscriber(const EventFwk::CommonEventSubscribeInfo& subscribeInfo,
605     const sptr<CommonEventCollect>& collect)
606     :EventFwk::CommonEventSubscriber(subscribeInfo), collect_(collect) {}
607 
OnReceiveEvent(const EventFwk::CommonEventData & data)608 void CommonEventSubscriber::OnReceiveEvent(const EventFwk::CommonEventData& data)
609 {
610     std::string action = data.GetWant().GetAction();
611     int32_t code = data.GetCode();
612     auto collect = collect_.promote();
613     if (collect == nullptr) {
614         HILOGE("CommonEventCollect collect is nullptr");
615         return;
616     }
617     collect->SaveAction(action);
618     int64_t extraDataId = collect->SaveOnDemandReasonExtraData(data);
619     HILOGI("RecvEvent:%{public}s,%{public}d_%{public}d", action.c_str(), code, static_cast<int32_t>(extraDataId));
620     collect->SaveOnDemandConditionExtraData(data);
621     OnDemandEvent event = {COMMON_EVENT, action, std::to_string(code), extraDataId};
622     collect->ReportEvent(event);
623 }
624 } // namespace OHOS
625