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 "bundle_active_period_stats.h"
17 #include "bundle_active_event.h"
18
19 namespace OHOS {
20 namespace DeviceUsageStats {
BundleActivePeriodStats()21 BundleActivePeriodStats::BundleActivePeriodStats()
22 {
23 userId_ = -1;
24 beginTime_ = 0;
25 endTime_ = 0;
26 lastTimeSaved_ = 0;
27 bundleStats_.clear();
28 events_.events_.clear();
29 packetNamesCache_.clear();
30 }
31
GetOrCreateUsageStats(const std::string & bundleName)32 std::shared_ptr<BundleActivePackageStats> BundleActivePeriodStats::GetOrCreateUsageStats(
33 const std::string& bundleName)
34 {
35 std::map<std::string, std::shared_ptr<BundleActivePackageStats>>::iterator it = bundleStats_.find(bundleName);
36 if (it == bundleStats_.end()) {
37 std::shared_ptr<BundleActivePackageStats> insertedStats = std::make_shared<BundleActivePackageStats>();
38 insertedStats->endTimeStamp_ = endTime_;
39 insertedStats->bundleName_ = GetCachedString(bundleName);
40 bundleStats_[insertedStats->bundleName_] = insertedStats;
41 }
42 return bundleStats_[bundleName];
43 }
44
Update(const std::string bundleName,const std::string longTimeTaskName,const int64_t timeStamp,const int32_t eventId,const std::string abilityId)45 void BundleActivePeriodStats::Update(const std::string bundleName, const std::string longTimeTaskName,
46 const int64_t timeStamp, const int32_t eventId, const std::string abilityId)
47 {
48 if (eventId == BundleActiveEvent::SHUTDOWN || eventId == BundleActiveEvent::FLUSH) {
49 for (std::map<std::string, std::shared_ptr<BundleActivePackageStats>>::iterator it = bundleStats_.begin();
50 it != bundleStats_.end(); ++it) {
51 std::shared_ptr<BundleActivePackageStats> tmpUsageStats = it->second;
52 if (tmpUsageStats != nullptr) {
53 tmpUsageStats->Update("", timeStamp, eventId, abilityId);
54 }
55 }
56 } else if (BundleActiveEvent::IsBundleEvent(eventId)) {
57 auto usageStats = GetOrCreateUsageStats(bundleName);
58 usageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
59 }
60 if (timeStamp > endTime_) {
61 endTime_ = timeStamp;
62 }
63 }
64
AddEvent(BundleActiveEvent event)65 void BundleActivePeriodStats::AddEvent(BundleActiveEvent event)
66 {
67 event.bundleName_ = GetCachedString(event.bundleName_);
68 if (!event.continuousTaskAbilityName_.empty()) {
69 event.continuousTaskAbilityName_ = GetCachedString(event.continuousTaskAbilityName_);
70 }
71 events_.Insert(event);
72 if (event.timeStamp_ > endTime_) {
73 endTime_ = event.timeStamp_;
74 }
75 }
76
CommitTime(const int64_t timeStamp)77 void BundleActivePeriodStats::CommitTime(const int64_t timeStamp)
78 {
79 interactiveTracker_.CommitTime(timeStamp);
80 noninteractiveTracker_.CommitTime(timeStamp);
81 keyguardShownTracker_.CommitTime(timeStamp);
82 keyguardHiddenTracker_.CommitTime(timeStamp);
83 }
84
UpdateScreenInteractive(const int64_t timeStamp)85 void BundleActivePeriodStats::UpdateScreenInteractive(const int64_t timeStamp)
86 {
87 interactiveTracker_.Update(timeStamp);
88 noninteractiveTracker_.CommitTime(timeStamp);
89 }
90
UpdateScreenNonInteractive(const int64_t timeStamp)91 void BundleActivePeriodStats::UpdateScreenNonInteractive(const int64_t timeStamp)
92 {
93 noninteractiveTracker_.Update(timeStamp);
94 interactiveTracker_.CommitTime(timeStamp);
95 }
96
UpdateKeyguardShown(const int64_t timeStamp)97 void BundleActivePeriodStats::UpdateKeyguardShown(const int64_t timeStamp)
98 {
99 keyguardShownTracker_.Update(timeStamp);
100 keyguardHiddenTracker_.CommitTime(timeStamp);
101 }
102
UpdateKeyguardHidden(const int64_t timeStamp)103 void BundleActivePeriodStats::UpdateKeyguardHidden(const int64_t timeStamp)
104 {
105 keyguardHiddenTracker_.Update(timeStamp);
106 keyguardShownTracker_.CommitTime(timeStamp);
107 }
108
AddEventStatsTo(std::vector<BundleActiveEventStats> & eventStatsList)109 void BundleActivePeriodStats::AddEventStatsTo(std::vector<BundleActiveEventStats>& eventStatsList)
110 {
111 interactiveTracker_.AddToEventStats(
112 eventStatsList, BundleActiveEvent::SCREEN_INTERACTIVE, beginTime_, endTime_);
113 noninteractiveTracker_.AddToEventStats(
114 eventStatsList, BundleActiveEvent::SCREEN_NON_INTERACTIVE, beginTime_, endTime_);
115 keyguardShownTracker_.AddToEventStats(
116 eventStatsList, BundleActiveEvent::KEYGUARD_SHOWN, beginTime_, endTime_);
117 keyguardHiddenTracker_.AddToEventStats(
118 eventStatsList, BundleActiveEvent::KEYGUARD_HIDDEN, beginTime_, endTime_);
119 }
120
GetCachedString(std::string str)121 std::string BundleActivePeriodStats::GetCachedString(std::string str)
122 {
123 std::set<std::string>::iterator it = packetNamesCache_.find(str);
124 if (it == packetNamesCache_.end()) {
125 packetNamesCache_.insert(str);
126 return str;
127 }
128 return *it;
129 }
130 } // namespace DeviceUsageStats
131 } // namespace OHOS
132
133