Merge "Simplify initialization and add setValue to support parceling" (880ca6d5) · Commits · e / os / android_frameworks_native

libs/battery/LongArrayMultiStateCounterTest.cpp

+17 −2

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

	TEST_F(LongArrayMultiStateCounterTest, stateChange) {		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.setState(1, 2000);
	testCounter.updateValue(std::vector<uint64_t>({100, 200, 300, 400}), 3000);		testCounter.updateValue(std::vector<uint64_t>({100, 200, 300, 400}), 3000);

	@@ -34,7 +36,9 @@ TEST_F(LongArrayMultiStateCounterTest, stateChange) {
	}		}

	TEST_F(LongArrayMultiStateCounterTest, accumulation) {		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.setState(1, 2000);
	testCounter.updateValue(std::vector<uint64_t>({100, 200, 300, 400}), 3000);		testCounter.updateValue(std::vector<uint64_t>({100, 200, 300, 400}), 3000);
	testCounter.setState(0, 4000);		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));		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 battery
	} // namespace android		} // namespace android

libs/battery/MultiStateCounter.h

+68 −39

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

	public:		public:
	MultiStateCounter(uint16_t stateCount, state_t initialState, const T& emptyValue,		MultiStateCounter(uint16_t stateCount, const T& emptyValue);
	time_t timestamp);

	virtual ~MultiStateCounter();		virtual ~MultiStateCounter();

	void setState(state_t state, time_t timestamp);		void setState(state_t state, time_t timestamp);

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

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

			uint16_t getStateCount();

	const T& getCount(state_t state);		const T& getCount(state_t state);

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

	template <class T>		template <class T>
	MultiStateCounter<T>::MultiStateCounter(uint16_t stateCount, state_t initialState,		MultiStateCounter<T>::MultiStateCounter(uint16_t stateCount, const T& emptyValue)
	const T& emptyValue, time_t timestamp)
	: stateCount(stateCount),		: stateCount(stateCount),
	currentState(initialState),		currentState(0),
	lastStateChangeTimestamp(timestamp),		lastStateChangeTimestamp(-1),
	emptyValue(emptyValue),		emptyValue(emptyValue),
	lastValue(emptyValue),		lastValue(emptyValue),
	lastUpdateTimestamp(timestamp),		lastUpdateTimestamp(-1),
	deltaValue(emptyValue) {		deltaValue(emptyValue) {
	states = new State[stateCount];		states = new State[stateCount];
	for (int i = 0; i < stateCount; i++) {		for (int i = 0; i < stateCount; i++) {
	@@ -109,6 +111,7 @@ MultiStateCounter<T>::~MultiStateCounter() {

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

			template <class T>
			void MultiStateCounter<T>::setValue(state_t state, const T& value) {
			states[state].counter = value;
			}

	template <class T>		template <class T>
	void MultiStateCounter<T>::updateValue(const T& value, time_t timestamp) {		void MultiStateCounter<T>::updateValue(const T& value, time_t timestamp) {
	// Confirm the current state for the side-effect of updating the time-in-state		// Confirm the current state for the side-effect of updating the time-in-state
	// counter for the current state.		// counter for the current state.
	setState(currentState, timestamp);		setState(currentState, timestamp);

			if (lastUpdateTimestamp >= 0) {
	if (timestamp > lastUpdateTimestamp) {		if (timestamp > lastUpdateTimestamp) {
	if (delta(lastValue, value, &deltaValue)) {		if (delta(lastValue, value, &deltaValue)) {
	time_t timeSinceUpdate = timestamp - lastUpdateTimestamp;		time_t timeSinceUpdate = timestamp - lastUpdateTimestamp;
	@@ -145,17 +155,24 @@ void MultiStateCounter<T>::updateValue(const T& value, time_t timestamp) {
	} else {		} else {
	std::stringstream str;		std::stringstream str;
	str << "updateValue is called with a value " << valueToString(value)		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());		ALOGE("%s", str.str().c_str());
	}		}
	} else if (timestamp < lastUpdateTimestamp) {		} else if (timestamp < lastUpdateTimestamp) {
	ALOGE("updateValue is called with an earlier timestamp: %lu, previous timestamp: %lu\n",		ALOGE("updateValue is called with an earlier timestamp: %lu, previous timestamp: %lu\n",
	(unsigned long)timestamp, (unsigned long)lastUpdateTimestamp);		(unsigned long)timestamp, (unsigned long)lastUpdateTimestamp);
	}		}
			}
	lastValue = value;		lastValue = value;
	lastUpdateTimestamp = timestamp;		lastUpdateTimestamp = timestamp;
	}		}

			template <class T>
			uint16_t MultiStateCounter<T>::getStateCount() {
			return stateCount;
			}

	template <class T>		template <class T>
	const T& MultiStateCounter<T>::getCount(state_t state) {		const T& MultiStateCounter<T>::getCount(state_t state) {
	return states[state].counter;		return states[state].counter;
	@@ -164,17 +181,29 @@ const T& MultiStateCounter<T>::getCount(state_t state) {
	template <class T>		template <class T>
	std::string MultiStateCounter<T>::toString() {		std::string MultiStateCounter<T>::toString() {
	std::stringstream str;		std::stringstream str;
	str << "currentState: " << currentState		str << "[";
	<< " lastStateChangeTimestamp: " << lastStateChangeTimestamp
	<< " lastUpdateTimestamp: " << lastUpdateTimestamp << " states: [";
	for (int i = 0; i < stateCount; i++) {		for (int i = 0; i < stateCount; i++) {
	if (i != 0) {		if (i != 0) {
	str << ", ";		str << ", ";
	}		}
	str << i << ": time: " << states[i].timeInStateSinceUpdate		str << i << ": " << valueToString(states[i].counter);
	<< " counter: " << valueToString(states[i].counter);		if (states[i].timeInStateSinceUpdate > 0) {
			str << " timeInStateSinceUpdate: " << states[i].timeInStateSinceUpdate;
			}
	}		}
	str << "]";		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();		return str.str();
	}		}

libs/battery/MultiStateCounterTest.cpp

+30 −5

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

	TEST_F(MultiStateCounterTest, constructor) {		TEST_F(MultiStateCounterTest, constructor) {
	DoubleMultiStateCounter testCounter(3, 1, 0, 1000);		DoubleMultiStateCounter testCounter(3, 0);
	testCounter.setState(1, 2000);		testCounter.updateValue(0, 0);
			testCounter.setState(1, 0);
	testCounter.updateValue(3.14, 3000);		testCounter.updateValue(3.14, 3000);

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

	TEST_F(MultiStateCounterTest, stateChange) {		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.setState(2, 1000);
	testCounter.updateValue(6.0, 3000);		testCounter.updateValue(6.0, 3000);

	@@ -69,7 +72,9 @@ TEST_F(MultiStateCounterTest, stateChange) {
	}		}

	TEST_F(MultiStateCounterTest, timeAdjustment_setState) {		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);		testCounter.setState(2, 2000);

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

	TEST_F(MultiStateCounterTest, timeAdjustment_updateValue) {		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);		testCounter.updateValue(6.0, 2000);

	// Time moves back. The negative delta from 2000 to 1000 is ignored		// 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));		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 battery
	} // namespace android		} // namespace android

libs/battery/LongArrayMultiStateCounter.cpp

+1 −1

File changed.

Contains only whitespace changes.