1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef SIMPLE_CONDITION_TRACKER_H
18 #define SIMPLE_CONDITION_TRACKER_H
19 
20 #include <gtest/gtest_prod.h>
21 #include "ConditionTracker.h"
22 #include "config/ConfigKey.h"
23 #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
24 #include "stats_util.h"
25 
26 namespace android {
27 namespace os {
28 namespace statsd {
29 
30 class SimpleConditionTracker : public virtual ConditionTracker {
31 public:
32     SimpleConditionTracker(const ConfigKey& key, const int64_t& id, const int index,
33                            const SimplePredicate& simplePredicate,
34                            const std::unordered_map<int64_t, int>& trackerNameIndexMap);
35 
36     ~SimpleConditionTracker();
37 
38     bool init(const std::vector<Predicate>& allConditionConfig,
39               const std::vector<sp<ConditionTracker>>& allConditionTrackers,
40               const std::unordered_map<int64_t, int>& conditionIdIndexMap, std::vector<bool>& stack,
41               std::vector<ConditionState>& initialConditionCache) override;
42 
43     void evaluateCondition(const LogEvent& event,
44                            const std::vector<MatchingState>& eventMatcherValues,
45                            const std::vector<sp<ConditionTracker>>& mAllConditions,
46                            std::vector<ConditionState>& conditionCache,
47                            std::vector<bool>& changedCache) override;
48 
49     void isConditionMet(const ConditionKey& conditionParameters,
50                         const std::vector<sp<ConditionTracker>>& allConditions,
51                         const bool isPartialLink,
52                         std::vector<ConditionState>& conditionCache) const override;
53 
getChangedToTrueDimensions(const std::vector<sp<ConditionTracker>> & allConditions)54     virtual const std::set<HashableDimensionKey>* getChangedToTrueDimensions(
55             const std::vector<sp<ConditionTracker>>& allConditions) const {
56         if (mSliced) {
57             return &mLastChangedToTrueDimensions;
58         } else {
59             return nullptr;
60         }
61     }
62 
getChangedToFalseDimensions(const std::vector<sp<ConditionTracker>> & allConditions)63     virtual const std::set<HashableDimensionKey>* getChangedToFalseDimensions(
64             const std::vector<sp<ConditionTracker>>& allConditions) const {
65         if (mSliced) {
66             return &mLastChangedToFalseDimensions;
67         } else {
68             return nullptr;
69         }
70     }
71 
getTrueSlicedDimensions(const std::vector<sp<ConditionTracker>> & allConditions,std::set<HashableDimensionKey> * dimensions)72     void getTrueSlicedDimensions(
73             const std::vector<sp<ConditionTracker>>& allConditions,
74             std::set<HashableDimensionKey>* dimensions) const override {
75         for (const auto& itr : mSlicedConditionState) {
76             if (itr.second > 0) {
77                 dimensions->insert(itr.first);
78             }
79         }
80     }
81 
IsChangedDimensionTrackable()82     bool IsChangedDimensionTrackable() const  override { return true; }
83 
IsSimpleCondition()84     bool IsSimpleCondition() const  override { return true; }
85 
equalOutputDimensions(const std::vector<sp<ConditionTracker>> & allConditions,const vector<Matcher> & dimensions)86     bool equalOutputDimensions(
87         const std::vector<sp<ConditionTracker>>& allConditions,
88         const vector<Matcher>& dimensions) const override {
89             return equalDimensions(mOutputDimensions, dimensions);
90     }
91 
92 private:
93     const ConfigKey mConfigKey;
94     // The index of the LogEventMatcher which defines the start.
95     int mStartLogMatcherIndex;
96 
97     // The index of the LogEventMatcher which defines the end.
98     int mStopLogMatcherIndex;
99 
100     // if the start end needs to be nested.
101     bool mCountNesting;
102 
103     // The index of the LogEventMatcher which defines the stop all.
104     int mStopAllLogMatcherIndex;
105 
106     ConditionState mInitialValue;
107 
108     std::vector<Matcher> mOutputDimensions;
109 
110     bool mContainANYPositionInInternalDimensions;
111 
112     std::set<HashableDimensionKey> mLastChangedToTrueDimensions;
113     std::set<HashableDimensionKey> mLastChangedToFalseDimensions;
114 
115     int mDimensionTag;
116 
117     std::map<HashableDimensionKey, int> mSlicedConditionState;
118 
119     void handleStopAll(std::vector<ConditionState>& conditionCache,
120                        std::vector<bool>& changedCache);
121 
122     void handleConditionEvent(const HashableDimensionKey& outputKey, bool matchStart,
123                               ConditionState* conditionCache, bool* changedCache);
124 
125     bool hitGuardRail(const HashableDimensionKey& newKey);
126 
127     void dumpState();
128 
129     FRIEND_TEST(SimpleConditionTrackerTest, TestSlicedCondition);
130     FRIEND_TEST(SimpleConditionTrackerTest, TestSlicedWithNoOutputDim);
131     FRIEND_TEST(SimpleConditionTrackerTest, TestStopAll);
132 };
133 
134 }  // namespace statsd
135 }  // namespace os
136 }  // namespace android
137 
138 #endif  // SIMPLE_CONDITION_TRACKER_H
139