Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 880ca6d5 authored by Dmitri Plotnikov's avatar Dmitri Plotnikov Committed by Android (Google) Code Review
Browse files

Merge "Simplify initialization and add setValue to support parceling"

parents 31633d33 12aaf8e3

libs/battery/LongArrayMultiStateCounterTest.cpp

+17 −2
Original line number Diff line number Diff line
@@ -24,7 +24,9 @@ namespace battery { 
class LongArrayMultiStateCounterTest : public testing::Test {};



TEST_F(LongArrayMultiStateCounterTest, stateChange) {

    LongArrayMultiStateCounter testCounter(2, 0, std::vector<uint64_t>(4), 1000);

    LongArrayMultiStateCounter testCounter(2, std::vector<uint64_t>(4));

    testCounter.updateValue(std::vector<uint64_t>({0, 0, 0, 0}), 1000);

    testCounter.setState(0, 1000);

    testCounter.setState(1, 2000);

    testCounter.updateValue(std::vector<uint64_t>({100, 200, 300, 400}), 3000);
@@ -34,7 +36,9 @@ TEST_F(LongArrayMultiStateCounterTest, stateChange) { 
}



TEST_F(LongArrayMultiStateCounterTest, accumulation) {

    LongArrayMultiStateCounter testCounter(2, 0, std::vector<uint64_t>(4), 1000);

    LongArrayMultiStateCounter testCounter(2, std::vector<uint64_t>(4));

    testCounter.updateValue(std::vector<uint64_t>({0, 0, 0, 0}), 1000);

    testCounter.setState(0, 1000);

    testCounter.setState(1, 2000);

    testCounter.updateValue(std::vector<uint64_t>({100, 200, 300, 400}), 3000);

    testCounter.setState(0, 4000);
@@ -50,5 +54,16 @@ TEST_F(LongArrayMultiStateCounterTest, accumulation) { 
    EXPECT_EQ(std::vector<uint64_t>({70, 120, 170, 220}), testCounter.getCount(1));

}



TEST_F(LongArrayMultiStateCounterTest, toString) {

    LongArrayMultiStateCounter testCounter(2, std::vector<uint64_t>(4));

    testCounter.updateValue(std::vector<uint64_t>({0, 0, 0, 0}), 1000);

    testCounter.setState(0, 1000);

    testCounter.setState(1, 2000);

    testCounter.updateValue(std::vector<uint64_t>({100, 200, 300, 400}), 3000);



    EXPECT_STREQ("[0: {50, 100, 150, 200}, 1: {50, 100, 150, 200}] updated: 3000 currentState: 1",

                 testCounter.toString().c_str());

}



} // namespace battery

} // namespace android

libs/battery/MultiStateCounter.h

+68 −39
Original line number Diff line number Diff line
@@ -51,15 +51,18 @@ class MultiStateCounter { 
    State* states;



public:

    MultiStateCounter(uint16_t stateCount, state_t initialState, const T& emptyValue,

                      time_t timestamp);

    MultiStateCounter(uint16_t stateCount, const T& emptyValue);



    virtual ~MultiStateCounter();



    void setState(state_t state, time_t timestamp);



    void setValue(state_t state, const T& value);



    void updateValue(const T& value, time_t timestamp);



    uint16_t getStateCount();



    const T& getCount(state_t state);



    std::string toString();
@@ -86,14 +89,13 @@ private: 
// Since MultiStateCounter is a template, the implementation must be inlined.



template <class T>

MultiStateCounter<T>::MultiStateCounter(uint16_t stateCount, state_t initialState,

                                        const T& emptyValue, time_t timestamp)

MultiStateCounter<T>::MultiStateCounter(uint16_t stateCount, const T& emptyValue)

      : stateCount(stateCount),

        currentState(initialState),

        lastStateChangeTimestamp(timestamp),

        currentState(0),

        lastStateChangeTimestamp(-1),

        emptyValue(emptyValue),

        lastValue(emptyValue),

        lastUpdateTimestamp(timestamp),

        lastUpdateTimestamp(-1),

        deltaValue(emptyValue) {

    states = new State[stateCount];

    for (int i = 0; i < stateCount; i++) {
@@ -109,6 +111,7 @@ MultiStateCounter<T>::~MultiStateCounter() { 


template <class T>

void MultiStateCounter<T>::setState(state_t state, time_t timestamp) {

    if (lastStateChangeTimestamp >= 0) {

        if (timestamp >= lastStateChangeTimestamp) {

            states[currentState].timeInStateSinceUpdate += timestamp - lastStateChangeTimestamp;

        } else {
@@ -122,16 +125,23 @@ void MultiStateCounter<T>::setState(state_t state, time_t timestamp) { 
                states[i].timeInStateSinceUpdate = 0;

            }

        }

    }

    currentState = state;

    lastStateChangeTimestamp = timestamp;

}



template <class T>

void MultiStateCounter<T>::setValue(state_t state, const T& value) {

    states[state].counter = value;

}



template <class T>

void MultiStateCounter<T>::updateValue(const T& value, time_t timestamp) {

    // Confirm the current state for the side-effect of updating the time-in-state

    // counter for the current state.

    setState(currentState, timestamp);



    if (lastUpdateTimestamp >= 0) {

        if (timestamp > lastUpdateTimestamp) {

            if (delta(lastValue, value, &deltaValue)) {

                time_t timeSinceUpdate = timestamp - lastUpdateTimestamp;
@@ -145,17 +155,24 @@ void MultiStateCounter<T>::updateValue(const T& value, time_t timestamp) { 
            } else {

                std::stringstream str;

                str << "updateValue is called with a value " << valueToString(value)

                << ", which is lower than the previous value " << valueToString(lastValue) << "\n";

                    << ", which is lower than the previous value " << valueToString(lastValue)

                    << "\n";

                ALOGE("%s", str.str().c_str());

            }

        } else if (timestamp < lastUpdateTimestamp) {

            ALOGE("updateValue is called with an earlier timestamp: %lu, previous timestamp: %lu\n",

                  (unsigned long)timestamp, (unsigned long)lastUpdateTimestamp);

        }

    }

    lastValue = value;

    lastUpdateTimestamp = timestamp;

}



template <class T>

uint16_t MultiStateCounter<T>::getStateCount() {

    return stateCount;

}



template <class T>

const T& MultiStateCounter<T>::getCount(state_t state) {

    return states[state].counter;
@@ -164,17 +181,29 @@ const T& MultiStateCounter<T>::getCount(state_t state) { 
template <class T>

std::string MultiStateCounter<T>::toString() {

    std::stringstream str;

    str << "currentState: " << currentState

        << " lastStateChangeTimestamp: " << lastStateChangeTimestamp

        << " lastUpdateTimestamp: " << lastUpdateTimestamp << " states: [";

    str << "[";

    for (int i = 0; i < stateCount; i++) {

        if (i != 0) {

            str << ", ";

        }

        str << i << ": time: " << states[i].timeInStateSinceUpdate

            << " counter: " << valueToString(states[i].counter);

        str << i << ": " << valueToString(states[i].counter);

        if (states[i].timeInStateSinceUpdate > 0) {

            str << " timeInStateSinceUpdate: " << states[i].timeInStateSinceUpdate;

        }

    }

    str << "]";

    if (lastUpdateTimestamp >= 0) {

        str << " updated: " << lastUpdateTimestamp;

    }

    if (lastStateChangeTimestamp >= 0) {

        str << " currentState: " << currentState;

        if (lastStateChangeTimestamp > lastUpdateTimestamp) {

            str << " stateChanged: " << lastStateChangeTimestamp;

        }

    } else {

        str << " currentState: none";

    }



    return str.str();

}

libs/battery/MultiStateCounterTest.cpp

+30 −5
Original line number Diff line number Diff line
@@ -49,8 +49,9 @@ std::string DoubleMultiStateCounter::valueToString(const double& v) const { 
class MultiStateCounterTest : public testing::Test {};



TEST_F(MultiStateCounterTest, constructor) {

    DoubleMultiStateCounter testCounter(3, 1, 0, 1000);

    testCounter.setState(1, 2000);

    DoubleMultiStateCounter testCounter(3, 0);

    testCounter.updateValue(0, 0);

    testCounter.setState(1, 0);

    testCounter.updateValue(3.14, 3000);



    EXPECT_DOUBLE_EQ(0, testCounter.getCount(0));
@@ -59,7 +60,9 @@ TEST_F(MultiStateCounterTest, constructor) { 
}



TEST_F(MultiStateCounterTest, stateChange) {

    DoubleMultiStateCounter testCounter(3, 1, 0, 0);

    DoubleMultiStateCounter testCounter(3, 0);

    testCounter.updateValue(0, 0);

    testCounter.setState(1, 0);

    testCounter.setState(2, 1000);

    testCounter.updateValue(6.0, 3000);
@@ -69,7 +72,9 @@ TEST_F(MultiStateCounterTest, stateChange) { 
}



TEST_F(MultiStateCounterTest, timeAdjustment_setState) {

    DoubleMultiStateCounter testCounter(3, 1, 0, 0);

    DoubleMultiStateCounter testCounter(3, 0);

    testCounter.updateValue(0, 0);

    testCounter.setState(1, 0);

    testCounter.setState(2, 2000);



    // Time moves back
@@ -88,7 +93,9 @@ TEST_F(MultiStateCounterTest, timeAdjustment_setState) { 
}



TEST_F(MultiStateCounterTest, timeAdjustment_updateValue) {

    DoubleMultiStateCounter testCounter(1, 0, 0, 0);

    DoubleMultiStateCounter testCounter(1, 0);

    testCounter.updateValue(0, 0);

    testCounter.setState(0, 0);

    testCounter.updateValue(6.0, 2000);



    // Time moves back. The negative delta from 2000 to 1000 is ignored
@@ -101,5 +108,23 @@ TEST_F(MultiStateCounterTest, timeAdjustment_updateValue) { 
    EXPECT_DOUBLE_EQ(9.0, testCounter.getCount(0));

}



TEST_F(MultiStateCounterTest, toString) {

    DoubleMultiStateCounter testCounter(2, 0);



    EXPECT_STREQ("[0: 0.000000, 1: 0.000000] currentState: none", testCounter.toString().c_str());



    testCounter.updateValue(0, 0);

    testCounter.setState(1, 0);

    testCounter.setState(1, 2000);

    EXPECT_STREQ("[0: 0.000000, 1: 0.000000 timeInStateSinceUpdate: 2000]"

                 " updated: 0 currentState: 1 stateChanged: 2000",

                 testCounter.toString().c_str());



    testCounter.updateValue(3.14, 3000);



    EXPECT_STREQ("[0: 0.000000, 1: 3.140000] updated: 3000 currentState: 1",

                 testCounter.toString().c_str());

}



} // namespace battery

} // namespace android

libs/battery/LongArrayMultiStateCounter.cpp

+1 −1

File changed.

Contains only whitespace changes.