powerstats: Implement EnergyConsumer API

Also update API and type names for rest of the implementation

Bug: 168831183
Test: dumpsys android.hardware.powerstats.IPowerStats/default
Change-Id: I47de1161a171df37ab0ade60dd8dece1f7edbc0c

10 files changed, 130 insertions, 134 deletions

diff --git a/powerstats/PowerStatsAidl.cpp b/powerstats/PowerStatsAidl.cpp
index 8e2ffd77..086a6488 100644
--- a/powerstats/PowerStatsAidl.cpp
+++ b/powerstats/PowerStatsAidl.cpp
@@ -35,10 +35,6 @@ namespace android {
 namespace hardware {
 namespace powerstats {
 
-void PowerStats::setRailDataProvider(std::unique_ptr<IRailEnergyDataProvider> p) {
-    mRailEnergyDataProvider = std::move(p);
-}
-
 void PowerStats::addStateResidencyDataProvider(sp<IStateResidencyDataProvider> p) {
     int32_t id = mPowerEntityInfos.size();
 
@@ -53,32 +49,24 @@ void PowerStats::addStateResidencyDataProvider(sp<IStateResidencyDataProvider> p
     }
 }
 
-ndk::ScopedAStatus PowerStats::getEnergyData(const std::vector<int32_t> &in_railIndices,
-                                             std::vector<EnergyData> *_aidl_return) {
-    if (!mRailEnergyDataProvider) {
-        return ndk::ScopedAStatus::ok();
-    }
-    return mRailEnergyDataProvider->getEnergyData(in_railIndices, _aidl_return);
-}
-
 ndk::ScopedAStatus PowerStats::getPowerEntityInfo(std::vector<PowerEntityInfo> *_aidl_return) {
     *_aidl_return = mPowerEntityInfos;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus PowerStats::getPowerEntityStateResidencyData(
+ndk::ScopedAStatus PowerStats::getPowerEntityStateResidency(
         const std::vector<int32_t> &in_powerEntityIds,
-        std::vector<PowerEntityStateResidencyResult> *_aidl_return) {
+        std::vector<StateResidencyResult> *_aidl_return) {
     // If powerEntityIds is empty then return data for all supported entities
     if (in_powerEntityIds.empty() && !mPowerEntityInfos.empty()) {
         std::vector<int32_t> v(mPowerEntityInfos.size());
         std::iota(std::begin(v), std::end(v), 0);
-        return getPowerEntityStateResidencyData(v, _aidl_return);
+        return getPowerEntityStateResidency(v, _aidl_return);
     }
 
     binder_status_t err = STATUS_OK;
 
-    std::unordered_map<std::string, std::vector<PowerEntityStateResidencyData>> stateResidencies;
+    std::unordered_map<std::string, std::vector<StateResidency>> stateResidencies;
 
     for (const int32_t id : in_powerEntityIds) {
         // skip any invalid ids
@@ -96,7 +84,7 @@ ndk::ScopedAStatus PowerStats::getPowerEntityStateResidencyData(
         // Append results if we have them
         auto stateResidency = stateResidencies.find(powerEntityName);
         if (stateResidency != stateResidencies.end()) {
-            PowerEntityStateResidencyResult res = {
+            StateResidencyResult res = {
                     .powerEntityId = id,
                     .stateResidencyData = stateResidency->second,
             };
@@ -113,13 +101,38 @@ ndk::ScopedAStatus PowerStats::getPowerEntityStateResidencyData(
     return ndk::ScopedAStatus::fromStatus(err);
 }
 
-ndk::ScopedAStatus PowerStats::getRailInfo(std::vector<RailInfo> *_aidl_return) {
+ndk::ScopedAStatus PowerStats::getEnergyConsumerInfo(std::vector<EnergyConsumerId> *_aidl_return) {
+    (void)_aidl_return;
+    return ndk::ScopedAStatus::ok();
+}
+
+ndk::ScopedAStatus PowerStats::getEnergyConsumed(
+        const std::vector<EnergyConsumerId> &in_energyConsumerIds,
+        std::vector<EnergyConsumerResult> *_aidl_return) {
+    (void)in_energyConsumerIds;
+    (void)_aidl_return;
+    return ndk::ScopedAStatus::ok();
+}
+
+void PowerStats::setRailDataProvider(std::unique_ptr<IRailEnergyDataProvider> p) {
+    mRailEnergyDataProvider = std::move(p);
+}
+
+ndk::ScopedAStatus PowerStats::getEnergyMeterInfo(std::vector<ChannelInfo> *_aidl_return) {
     if (!mRailEnergyDataProvider) {
         return ndk::ScopedAStatus::ok();
     }
     return mRailEnergyDataProvider->getRailInfo(_aidl_return);
 }
 
+ndk::ScopedAStatus PowerStats::readEnergyMeters(const std::vector<int32_t> &in_channelIds,
+                                                std::vector<EnergyMeasurement> *_aidl_return) {
+    if (!mRailEnergyDataProvider) {
+        return ndk::ScopedAStatus::ok();
+    }
+    return mRailEnergyDataProvider->getRailEnergy(in_channelIds, _aidl_return);
+}
+
 void PowerStats::getEntityStateMaps(
         std::unordered_map<int32_t, std::string> *entityNames,
         std::unordered_map<int32_t, std::unordered_map<int32_t, std::string>> *stateNames) {
@@ -131,37 +144,36 @@ void PowerStats::getEntityStateMaps(
         stateNames->emplace(info.powerEntityId, std::unordered_map<int32_t, std::string>());
         auto &entityStateNames = stateNames->at(info.powerEntityId);
         for (const auto &state : info.states) {
-            entityStateNames.emplace(state.powerEntityStateId, state.powerEntityStateName);
+            entityStateNames.emplace(state.stateId, state.stateName);
         }
     }
 }
 
-void PowerStats::getRailEnergyMaps(
-        std::unordered_map<int32_t, std::pair<std::string, std::string>> *railNames) {
-    std::vector<RailInfo> infos;
-    getRailInfo(&infos);
+void PowerStats::getRailEnergyMaps(std::unordered_map<int32_t, std::string> *railNames) {
+    std::vector<ChannelInfo> infos;
+    getEnergyMeterInfo(&infos);
 
     for (const auto &info : infos) {
-        railNames->emplace(info.railIndex, std::make_pair(info.subsysName, info.railName));
+        railNames->emplace(info.channelId, info.channelName);
     }
 }
 
 void PowerStats::dumpRailEnergy(std::ostringstream &oss, bool delta) {
-    const char *headerFormat = "  %14s   %18s   %18s\n";
-    const char *dataFormat = "  %14s   %18s   %14.2f mWs\n";
-    const char *headerFormatDelta = "  %14s   %18s   %18s (%14s)\n";
-    const char *dataFormatDelta = "  %14s   %18s   %14.2f mWs (%14.2f)\n";
+    const char *headerFormat = "  %18s   %18s\n";
+    const char *dataFormat = "  %18s   %14.2f mWs\n";
+    const char *headerFormatDelta = "  %18s   %18s (%14s)\n";
+    const char *dataFormatDelta = "  %18s   %14.2f mWs (%14.2f)\n";
 
-    std::unordered_map<int32_t, std::pair<std::string, std::string>> railNames;
+    std::unordered_map<int32_t, std::string> railNames;
     getRailEnergyMaps(&railNames);
 
     oss << "\n============= PowerStats HAL 2.0 rail energy ==============\n";
 
-    std::vector<EnergyData> energyData;
-    getEnergyData({}, &energyData);
+    std::vector<EnergyMeasurement> energyData;
+    readEnergyMeters({}, &energyData);
 
     if (delta) {
-        static std::vector<EnergyData> prevEnergyData;
+        static std::vector<EnergyMeasurement> prevEnergyData;
         ::android::base::boot_clock::time_point curTime = ::android::base::boot_clock::now();
         static ::android::base::boot_clock::time_point prevTime = curTime;
 
@@ -169,25 +181,23 @@ void PowerStats::dumpRailEnergy(std::ostringstream &oss, bool delta) {
             << std::chrono::duration_cast<std::chrono::milliseconds>(curTime - prevTime).count()
             << " ms";
 
-        oss << ::android::base::StringPrintf(headerFormatDelta, "Subsys", "Rail",
-                                             "Cumulative Energy", "Delta   ");
+        oss << ::android::base::StringPrintf(headerFormatDelta, "Rail", "Cumulative Energy",
+                                             "Delta   ");
 
         std::unordered_map<int32_t, int64_t> prevEnergyDataMap;
         for (const auto &data : prevEnergyData) {
-            prevEnergyDataMap.emplace(data.railIndex, data.energyUWs);
+            prevEnergyDataMap.emplace(data.channelId, data.energyUWs);
         }
 
         for (const auto &data : energyData) {
-            const char *subsysName = railNames.at(data.railIndex).first.c_str();
-            const char *railName = railNames.at(data.railIndex).second.c_str();
-
-            auto prevEnergyDataIt = prevEnergyDataMap.find(data.railIndex);
+            auto prevEnergyDataIt = prevEnergyDataMap.find(data.channelId);
             int64_t deltaEnergy = 0;
             if (prevEnergyDataIt != prevEnergyDataMap.end()) {
                 deltaEnergy = data.energyUWs - prevEnergyDataIt->second;
             }
 
-            oss << ::android::base::StringPrintf(dataFormatDelta, subsysName, railName,
+            oss << ::android::base::StringPrintf(dataFormatDelta,
+                                                 railNames.at(data.channelId).c_str(),
                                                  static_cast<float>(data.energyUWs) / 1000.0,
                                                  static_cast<float>(deltaEnergy) / 1000.0);
         }
@@ -195,12 +205,10 @@ void PowerStats::dumpRailEnergy(std::ostringstream &oss, bool delta) {
         prevEnergyData = energyData;
         prevTime = curTime;
     } else {
-        oss << ::android::base::StringPrintf(headerFormat, "Subsys", "Rail", "Cumulative Energy");
+        oss << ::android::base::StringPrintf(headerFormat, "Rail", "Cumulative Energy");
 
         for (const auto &data : energyData) {
-            oss << ::android::base::StringPrintf(dataFormat,
-                                                 railNames.at(data.railIndex).first.c_str(),
-                                                 railNames.at(data.railIndex).second.c_str(),
+            oss << ::android::base::StringPrintf(dataFormat, railNames.at(data.channelId).c_str(),
                                                  static_cast<float>(data.energyUWs) / 1000.0);
         }
     }
@@ -223,11 +231,11 @@ void PowerStats::dumpStateResidency(std::ostringstream &oss, bool delta) {
 
     oss << "\n============= PowerStats HAL 2.0 state residencies ==============\n";
 
-    std::vector<PowerEntityStateResidencyResult> results;
-    getPowerEntityStateResidencyData({}, &results);
+    std::vector<StateResidencyResult> results;
+    getPowerEntityStateResidency({}, &results);
 
     if (delta) {
-        static std::vector<PowerEntityStateResidencyResult> prevResults;
+        static std::vector<StateResidencyResult> prevResults;
         ::android::base::boot_clock::time_point curTime = ::android::base::boot_clock::now();
         static ::android::base::boot_clock::time_point prevTime = curTime;
 
@@ -240,14 +248,13 @@ void PowerStats::dumpStateResidency(std::ostringstream &oss, bool delta) {
                                              "Last entry tstamp", "Delta ");
 
         // Process prevResults into a 2-tier lookup table for easy reference
-        std::unordered_map<int32_t, std::unordered_map<int32_t, PowerEntityStateResidencyData>>
-                prevResultsMap;
+        std::unordered_map<int32_t, std::unordered_map<int32_t, StateResidency>> prevResultsMap;
         for (const auto &prevResult : prevResults) {
             prevResultsMap.emplace(prevResult.powerEntityId,
-                                   std::unordered_map<int32_t, PowerEntityStateResidencyData>());
+                                   std::unordered_map<int32_t, StateResidency>());
             for (auto stateResidency : prevResult.stateResidencyData) {
                 prevResultsMap.at(prevResult.powerEntityId)
-                        .emplace(stateResidency.powerEntityStateId, stateResidency);
+                        .emplace(stateResidency.stateId, stateResidency);
             }
         }
 
@@ -260,9 +267,8 @@ void PowerStats::dumpStateResidency(std::ostringstream &oss, bool delta) {
 
             // Iterate over individual states within the current entity's new result
             for (const auto &stateResidency : result.stateResidencyData) {
-                const char *stateName = stateNames.at(result.powerEntityId)
-                                                .at(stateResidency.powerEntityStateId)
-                                                .c_str();
+                const char *stateName =
+                        stateNames.at(result.powerEntityId).at(stateResidency.stateId).c_str();
 
                 // If a previous result was found for the same entity, see if that
                 // result also contains data for the current state
@@ -271,7 +277,7 @@ void PowerStats::dumpStateResidency(std::ostringstream &oss, bool delta) {
                 int64_t deltaTimestamp = 0;
                 if (prevEntityResultIt != prevResultsMap.end()) {
                     auto prevStateResidencyIt =
-                            prevEntityResultIt->second.find(stateResidency.powerEntityStateId);
+                            prevEntityResultIt->second.find(stateResidency.stateId);
                     // If a previous result was found for the current entity and state, calculate
                     // the deltas and display them along with new result
                     if (prevStateResidencyIt != prevEntityResultIt->second.end()) {
@@ -300,9 +306,7 @@ void PowerStats::dumpStateResidency(std::ostringstream &oss, bool delta) {
             for (const auto &stateResidency : result.stateResidencyData) {
                 oss << ::android::base::StringPrintf(
                         dataFormat, entityNames.at(result.powerEntityId).c_str(),
-                        stateNames.at(result.powerEntityId)
-                                .at(stateResidency.powerEntityStateId)
-                                .c_str(),
+                        stateNames.at(result.powerEntityId).at(stateResidency.stateId).c_str(),
                         stateResidency.totalTimeInStateMs, stateResidency.totalStateEntryCount,
                         stateResidency.lastEntryTimestampMs);
             }
diff --git a/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp b/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp
index acf437f0..1b63c025 100644
--- a/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp
+++ b/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp
@@ -42,7 +42,7 @@ DisplayStateResidencyDataProvider::DisplayStateResidencyDataProvider(
     // Construct mResidencies
     mResidencies.reserve(mStates.size());
     for (int32_t i = 0; i < mStates.size(); ++i) {
-        PowerEntityStateResidencyData p = {.powerEntityStateId = i};
+        StateResidency p = {.stateId = i};
         mResidencies.emplace_back(p);
     }
 
@@ -71,7 +71,7 @@ DisplayStateResidencyDataProvider::~DisplayStateResidencyDataProvider() {
 }
 
 bool DisplayStateResidencyDataProvider::getResults(
-        std::unordered_map<std::string, std::vector<PowerEntityStateResidencyData>> *results) {
+        std::unordered_map<std::string, std::vector<StateResidency>> *results) {
     std::scoped_lock lk(mLock);
 
     // Get current time since boot in milliseconds
@@ -86,12 +86,12 @@ bool DisplayStateResidencyDataProvider::getResults(
     return true;
 }
 
-std::unordered_map<std::string, std::vector<PowerEntityStateInfo>>
+std::unordered_map<std::string, std::vector<StateInfo>>
 DisplayStateResidencyDataProvider::getInfo() {
-    std::vector<PowerEntityStateInfo> stateInfos;
+    std::vector<StateInfo> stateInfos;
     stateInfos.reserve(mStates.size());
     for (int32_t i = 0; i < mStates.size(); ++i) {
-        stateInfos.push_back({.powerEntityStateId = i, .powerEntityStateName = mStates[i]});
+        stateInfos.push_back({.stateId = i, .stateName = mStates[i]});
     }
 
     return {{mName, stateInfos}};
diff --git a/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp b/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp
index 8d4b893c..ca5ff431 100644
--- a/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp
+++ b/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp
@@ -52,7 +52,7 @@ static bool extractStat(const char *line, const std::string &prefix, uint64_t *s
     return true;
 }
 
-static bool parseState(PowerEntityStateResidencyData *data,
+static bool parseState(StateResidency *data,
                        const GenericStateResidencyDataProvider::StateResidencyConfig &config,
                        FILE *fp, char **line, size_t *len) {
     size_t numFieldsRead = 0;
@@ -106,7 +106,7 @@ static int32_t findNextIndex(const std::vector<T> &collection, FILE *fp, char **
     return -1;
 }
 
-static bool getStateData(std::vector<PowerEntityStateResidencyData> *result,
+static bool getStateData(std::vector<StateResidency> *result,
                          const std::vector<GenericStateResidencyDataProvider::StateResidencyConfig>
                                  &stateResidencyConfigs,
                          FILE *fp, char **line, size_t *len) {
@@ -125,7 +125,7 @@ static bool getStateData(std::vector<PowerEntityStateResidencyData> *result,
            (nextState = findNextIndex<GenericStateResidencyDataProvider::StateResidencyConfig>(
                     stateResidencyConfigs, fp, line, len, pred)) >= 0) {
         // Found a matching state header. Parse the contents
-        PowerEntityStateResidencyData data = {.powerEntityStateId = nextState};
+        StateResidency data = {.stateId = nextState};
         if (parseState(&data, stateResidencyConfigs[nextState], fp, line, len)) {
             result->emplace_back(data);
             ++numStatesRead;
@@ -143,7 +143,7 @@ static bool getStateData(std::vector<PowerEntityStateResidencyData> *result,
 }
 
 bool GenericStateResidencyDataProvider::getResults(
-        std::unordered_map<std::string, std::vector<PowerEntityStateResidencyData>> *results) {
+        std::unordered_map<std::string, std::vector<StateResidency>> *results) {
     // Using FILE* instead of std::ifstream for performance reasons
     std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(mPath.c_str(), "r"), fclose);
     if (!fp) {
@@ -166,7 +166,7 @@ bool GenericStateResidencyDataProvider::getResults(
            (nextConfig = findNextIndex<decltype(mPowerEntityConfigs)::value_type>(
                     mPowerEntityConfigs, fp.get(), &line, &len, pred)) >= 0) {
         // Found a matching header. Retrieve its state data
-        std::vector<PowerEntityStateResidencyData> result;
+        std::vector<StateResidency> result;
         if (getStateData(&result, mPowerEntityConfigs[nextConfig].mStateResidencyConfigs, fp.get(),
                          &line, &len)) {
             results->emplace(mPowerEntityConfigs[nextConfig].mName, result);
@@ -187,15 +187,14 @@ bool GenericStateResidencyDataProvider::getResults(
     return true;
 }
 
-std::unordered_map<std::string, std::vector<PowerEntityStateInfo>>
+std::unordered_map<std::string, std::vector<StateInfo>>
 GenericStateResidencyDataProvider::getInfo() {
-    std::unordered_map<std::string, std::vector<PowerEntityStateInfo>> ret;
+    std::unordered_map<std::string, std::vector<StateInfo>> ret;
     for (const auto &entityConfig : mPowerEntityConfigs) {
         int32_t stateId = 0;
-        std::vector<PowerEntityStateInfo> stateInfos;
+        std::vector<StateInfo> stateInfos;
         for (const auto &stateConfig : entityConfig.mStateResidencyConfigs) {
-            PowerEntityStateInfo stateInfo = {.powerEntityStateId = stateId++,
-                                              .powerEntityStateName = stateConfig.name};
+            StateInfo stateInfo = {.stateId = stateId++, .stateName = stateConfig.name};
             stateInfos.emplace_back(stateInfo);
         }
 
diff --git a/powerstats/dataproviders/IioRailEnergyDataProvider.cpp b/powerstats/dataproviders/IioRailEnergyDataProvider.cpp
index 1d6dbc21..3056af0e 100644
--- a/powerstats/dataproviders/IioRailEnergyDataProvider.cpp
+++ b/powerstats/dataproviders/IioRailEnergyDataProvider.cpp
@@ -56,7 +56,7 @@ void IioRailEnergyDataProvider::findIioPowerMonitorNodes() {
 
 void IioRailEnergyDataProvider::parsePowerRails() {
     std::string data;
-    int32_t index = 0;
+    int32_t id = 0;
     for (const auto &path : mDevicePaths) {
         // Get sampling rate
         unsigned long samplingRate;
@@ -78,12 +78,9 @@ void IioRailEnergyDataProvider::parsePowerRails() {
         while (std::getline(railNames, line)) {
             std::vector<std::string> words = ::android::base::Split(line, ":");
             if (words.size() == 2) {
-                mRailInfos.push_back({.railIndex = index,
-                                      .railName = words[0],
-                                      .subsysName = words[1],
-                                      .samplingRateHz = static_cast<int32_t>(samplingRate)});
-                mRailIndices.emplace(words[0], index);
-                index++;
+                mRailInfos.push_back({.channelId = id, .channelName = words[0]});
+                mRailIds.emplace(words[0], id);
+                id++;
             } else {
                 LOG(WARNING) << "Unexpected enabled rail format in " << path;
             }
@@ -122,13 +119,13 @@ int IioRailEnergyDataProvider::parseIioEnergyNode(std::string path) {
             }
         } else if (words.size() == 2) {
             std::string railName = words[0];
-            if (mRailIndices.count(railName) != 0) {
-                size_t index = mRailIndices[railName];
-                mReading[index].railIndex = index;
-                mReading[index].timestampMs = timestamp;
-                mReading[index].energyUWs = std::stoull(words[1]);
-                if (mReading[index].energyUWs == ULLONG_MAX) {
-                    LOG(WARNING) << "Potentially wrong energy value: " << mReading[index].energyUWs;
+            if (mRailIds.count(railName) != 0) {
+                size_t id = mRailIds[railName];
+                mReading[id].channelId = id;
+                mReading[id].timestampMs = timestamp;
+                mReading[id].energyUWs = std::stoull(words[1]);
+                if (mReading[id].energyUWs == ULLONG_MAX) {
+                    LOG(WARNING) << "Potentially wrong energy value: " << mReading[id].energyUWs;
                 }
             }
         } else {
@@ -140,8 +137,8 @@ int IioRailEnergyDataProvider::parseIioEnergyNode(std::string path) {
     return ret;
 }
 
-ndk::ScopedAStatus IioRailEnergyDataProvider::getEnergyData(
-        const std::vector<int32_t> &in_railIndices, std::vector<EnergyData> *_aidl_return) {
+ndk::ScopedAStatus IioRailEnergyDataProvider::getRailEnergy(
+        const std::vector<int32_t> &in_railIds, std::vector<EnergyMeasurement> *_aidl_return) {
     std::scoped_lock lock(mLock);
     binder_status_t ret = STATUS_OK;
     for (const auto &devicePath : mDevicePaths) {
@@ -151,13 +148,13 @@ ndk::ScopedAStatus IioRailEnergyDataProvider::getEnergyData(
         }
     }
 
-    if (in_railIndices.empty()) {
+    if (in_railIds.empty()) {
         *_aidl_return = mReading;
     } else {
-        _aidl_return->reserve(in_railIndices.size());
-        for (const auto &railIndex : in_railIndices) {
-            if (railIndex < mRailInfos.size()) {
-                _aidl_return->emplace_back(mReading[railIndex]);
+        _aidl_return->reserve(in_railIds.size());
+        for (const auto &railId : in_railIds) {
+            if (railId < mRailInfos.size()) {
+                _aidl_return->emplace_back(mReading[railId]);
             } else {
                 ret = STATUS_BAD_VALUE;
             }
@@ -166,7 +163,7 @@ ndk::ScopedAStatus IioRailEnergyDataProvider::getEnergyData(
     return ndk::ScopedAStatus::fromStatus(ret);
 }
 
-ndk::ScopedAStatus IioRailEnergyDataProvider::getRailInfo(std::vector<RailInfo> *_aidl_return) {
+ndk::ScopedAStatus IioRailEnergyDataProvider::getRailInfo(std::vector<ChannelInfo> *_aidl_return) {
     std::scoped_lock lk(mLock);
     *_aidl_return = mRailInfos;
     return ndk::ScopedAStatus::ok();
diff --git a/powerstats/dataproviders/WlanStateResidencyDataProvider.cpp b/powerstats/dataproviders/WlanStateResidencyDataProvider.cpp
index 668cd872..a148015f 100644
--- a/powerstats/dataproviders/WlanStateResidencyDataProvider.cpp
+++ b/powerstats/dataproviders/WlanStateResidencyDataProvider.cpp
@@ -44,9 +44,8 @@ static bool extractStat(const char *line, const std::string &prefix, uint64_t *s
 }
 
 bool WlanStateResidencyDataProvider::getResults(
-        std::unordered_map<std::string, std::vector<PowerEntityStateResidencyData>> *results) {
-    std::vector<PowerEntityStateResidencyData> result = {{.powerEntityStateId = ACTIVE_ID},
-                                                         {.powerEntityStateId = DEEPSLEEP_ID}};
+        std::unordered_map<std::string, std::vector<StateResidency>> *results) {
+    std::vector<StateResidency> result = {{.stateId = ACTIVE_ID}, {.stateId = DEEPSLEEP_ID}};
 
     std::string wlanDriverStatus = ::android::base::GetProperty("wlan.driver.status", "unloaded");
     if (wlanDriverStatus != "ok") {
@@ -99,12 +98,11 @@ bool WlanStateResidencyDataProvider::getResults(
     return true;
 }
 
-std::unordered_map<std::string, std::vector<PowerEntityStateInfo>>
-WlanStateResidencyDataProvider::getInfo() {
-    std::unordered_map<std::string, std::vector<PowerEntityStateInfo>> ret = {
+std::unordered_map<std::string, std::vector<StateInfo>> WlanStateResidencyDataProvider::getInfo() {
+    std::unordered_map<std::string, std::vector<StateInfo>> ret = {
             {mName,
-             {{.powerEntityStateId = ACTIVE_ID, .powerEntityStateName = "Active"},
-              {.powerEntityStateId = DEEPSLEEP_ID, .powerEntityStateName = "Deep-Sleep"}}},
+             {{.stateId = ACTIVE_ID, .stateName = "Active"},
+              {.stateId = DEEPSLEEP_ID, .stateName = "Deep-Sleep"}}},
     };
     return ret;
 }
diff --git a/powerstats/include/PowerStatsAidl.h b/powerstats/include/PowerStatsAidl.h
index 921f9bec..ea3488ea 100644
--- a/powerstats/include/PowerStatsAidl.h
+++ b/powerstats/include/PowerStatsAidl.h
@@ -35,17 +35,16 @@ class PowerStats : public BnPowerStats {
       public:
         virtual ~IStateResidencyDataProvider() = default;
         virtual bool getResults(
-                std::unordered_map<std::string, std::vector<PowerEntityStateResidencyData>>
-                        *results) = 0;
-        virtual std::unordered_map<std::string, std::vector<PowerEntityStateInfo>> getInfo() = 0;
+                std::unordered_map<std::string, std::vector<StateResidency>> *results) = 0;
+        virtual std::unordered_map<std::string, std::vector<StateInfo>> getInfo() = 0;
     };
 
     class IRailEnergyDataProvider {
       public:
         virtual ~IRailEnergyDataProvider() = default;
-        virtual ndk::ScopedAStatus getEnergyData(const std::vector<int32_t> &in_railIndices,
-                                                 std::vector<EnergyData> *_aidl_return) = 0;
-        virtual ndk::ScopedAStatus getRailInfo(std::vector<RailInfo> *_aidl_return) = 0;
+        virtual ndk::ScopedAStatus getRailEnergy(const std::vector<int32_t> &in_railIds,
+                                                 std::vector<EnergyMeasurement> *_aidl_return) = 0;
+        virtual ndk::ScopedAStatus getRailInfo(std::vector<ChannelInfo> *_aidl_return) = 0;
     };
 
     PowerStats() = default;
@@ -53,26 +52,28 @@ class PowerStats : public BnPowerStats {
     void addStateResidencyDataProvider(sp<IStateResidencyDataProvider> p);
 
     // Methods from aidl::android::hardware::powerstats::IPowerStats
-    ndk::ScopedAStatus getEnergyData(const std::vector<int32_t> &in_railIndices,
-                                     std::vector<EnergyData> *_aidl_return) override;
     ndk::ScopedAStatus getPowerEntityInfo(std::vector<PowerEntityInfo> *_aidl_return) override;
-    ndk::ScopedAStatus getPowerEntityStateResidencyData(
+    ndk::ScopedAStatus getPowerEntityStateResidency(
             const std::vector<int32_t> &in_powerEntityIds,
-            std::vector<PowerEntityStateResidencyResult> *_aidl_return) override;
-    ndk::ScopedAStatus getRailInfo(std::vector<RailInfo> *_aidl_return) override;
+            std::vector<StateResidencyResult> *_aidl_return) override;
+    ndk::ScopedAStatus getEnergyConsumerInfo(std::vector<EnergyConsumerId> *_aidl_return) override;
+    ndk::ScopedAStatus getEnergyConsumed(const std::vector<EnergyConsumerId> &in_energyConsumerIds,
+                                         std::vector<EnergyConsumerResult> *_aidl_return) override;
+    ndk::ScopedAStatus getEnergyMeterInfo(std::vector<ChannelInfo> *_aidl_return) override;
+    ndk::ScopedAStatus readEnergyMeters(const std::vector<int32_t> &in_channelIds,
+                                        std::vector<EnergyMeasurement> *_aidl_return) override;
     binder_status_t dump(int fd, const char **args, uint32_t numArgs) override;
 
   private:
     void getEntityStateMaps(
             std::unordered_map<int32_t, std::string> *entityNames,
             std::unordered_map<int32_t, std::unordered_map<int32_t, std::string>> *stateNames);
-    void getRailEnergyMaps(
-            std::unordered_map<int32_t, std::pair<std::string, std::string>> *railNames);
+    void getRailEnergyMaps(std::unordered_map<int32_t, std::string> *railNames);
     void dumpStateResidency(std::ostringstream &oss, bool delta);
     void dumpStateResidencyDelta(std::ostringstream &oss,
-                                 const std::vector<PowerEntityStateResidencyResult> &results);
+                                 const std::vector<StateResidencyResult> &results);
     void dumpStateResidencyOneShot(std::ostringstream &oss,
-                                   const std::vector<PowerEntityStateResidencyResult> &results);
+                                   const std::vector<StateResidencyResult> &results);
     void dumpRailEnergy(std::ostringstream &oss, bool delta);
 
     std::vector<sp<IStateResidencyDataProvider>> mStateResidencyDataProviders;
diff --git a/powerstats/include/dataproviders/DisplayStateResidencyDataProvider.h b/powerstats/include/dataproviders/DisplayStateResidencyDataProvider.h
index 91929390..48a317bf 100644
--- a/powerstats/include/dataproviders/DisplayStateResidencyDataProvider.h
+++ b/powerstats/include/dataproviders/DisplayStateResidencyDataProvider.h
@@ -43,9 +43,8 @@ class DisplayStateResidencyDataProvider : public PowerStats::IStateResidencyData
     ~DisplayStateResidencyDataProvider();
 
     // Methods from PowerStats::IStateResidencyDataProvider
-    bool getResults(std::unordered_map<std::string, std::vector<PowerEntityStateResidencyData>>
-                            *results) override;
-    std::unordered_map<std::string, std::vector<PowerEntityStateInfo>> getInfo() override;
+    bool getResults(std::unordered_map<std::string, std::vector<StateResidency>> *results) override;
+    std::unordered_map<std::string, std::vector<StateInfo>> getInfo() override;
 
   private:
     // Method associated with ::android::Thread. Poll for display state changes
@@ -64,7 +63,7 @@ class DisplayStateResidencyDataProvider : public PowerStats::IStateResidencyData
     // Lock to protect concurrent read/write to mResidencies and mCurState
     std::mutex mLock;
     // Accumulated display state stats indexed by mCurState
-    std::vector<PowerEntityStateResidencyData> mResidencies;
+    std::vector<StateResidency> mResidencies;
     // Index of current state
     int mCurState;
     // Looper to facilitate polling of display state file desciptor
diff --git a/powerstats/include/dataproviders/GenericStateResidencyDataProvider.h b/powerstats/include/dataproviders/GenericStateResidencyDataProvider.h
index 6abf680c..aee87d6d 100644
--- a/powerstats/include/dataproviders/GenericStateResidencyDataProvider.h
+++ b/powerstats/include/dataproviders/GenericStateResidencyDataProvider.h
@@ -61,9 +61,8 @@ class GenericStateResidencyDataProvider : public PowerStats::IStateResidencyData
     ~GenericStateResidencyDataProvider() = default;
 
     // Methods from PowerStats::IStateResidencyDataProvider
-    bool getResults(std::unordered_map<std::string, std::vector<PowerEntityStateResidencyData>>
-                            *results) override;
-    std::unordered_map<std::string, std::vector<PowerEntityStateInfo>> getInfo() override;
+    bool getResults(std::unordered_map<std::string, std::vector<StateResidency>> *results) override;
+    std::unordered_map<std::string, std::vector<StateInfo>> getInfo() override;
 
   private:
     const std::string mPath;
diff --git a/powerstats/include/dataproviders/IioRailEnergyDataProvider.h b/powerstats/include/dataproviders/IioRailEnergyDataProvider.h
index 2a7bc59a..06d49263 100644
--- a/powerstats/include/dataproviders/IioRailEnergyDataProvider.h
+++ b/powerstats/include/dataproviders/IioRailEnergyDataProvider.h
@@ -30,9 +30,9 @@ class IioRailEnergyDataProvider : public PowerStats::IRailEnergyDataProvider {
     IioRailEnergyDataProvider(const std::string &deviceName);
 
     // Methods from PowerStats::IRailEnergyDataProvider
-    ndk::ScopedAStatus getEnergyData(const std::vector<int32_t> &in_railIndices,
-                                     std::vector<EnergyData> *_aidl_return) override;
-    ndk::ScopedAStatus getRailInfo(std::vector<RailInfo> *_aidl_return) override;
+    ndk::ScopedAStatus getRailEnergy(const std::vector<int32_t> &in_railIds,
+                                     std::vector<EnergyMeasurement> *_aidl_return) override;
+    ndk::ScopedAStatus getRailInfo(std::vector<ChannelInfo> *_aidl_return) override;
 
   private:
     void findIioPowerMonitorNodes();
@@ -41,9 +41,9 @@ class IioRailEnergyDataProvider : public PowerStats::IRailEnergyDataProvider {
 
     std::mutex mLock;
     std::vector<std::string> mDevicePaths;
-    std::unordered_map<std::string, int32_t> mRailIndices;  // key: railName, value: railIndex
-    std::vector<RailInfo> mRailInfos;
-    std::vector<EnergyData> mReading;
+    std::unordered_map<std::string, int32_t> mRailIds;  // key: name, value: id
+    std::vector<ChannelInfo> mRailInfos;
+    std::vector<EnergyMeasurement> mReading;
 
     const std::string kDeviceName;
     const std::string kDeviceType = "iio:device";
diff --git a/powerstats/include/dataproviders/WlanStateResidencyDataProvider.h b/powerstats/include/dataproviders/WlanStateResidencyDataProvider.h
index 46c7edcc..64f2a18b 100644
--- a/powerstats/include/dataproviders/WlanStateResidencyDataProvider.h
+++ b/powerstats/include/dataproviders/WlanStateResidencyDataProvider.h
@@ -30,9 +30,8 @@ class WlanStateResidencyDataProvider : public PowerStats::IStateResidencyDataPro
     ~WlanStateResidencyDataProvider() = default;
 
     // Methods from PowerStats::IStateResidencyDataProvider
-    bool getResults(std::unordered_map<std::string, std::vector<PowerEntityStateResidencyData>>
-                            *results) override;
-    std::unordered_map<std::string, std::vector<PowerEntityStateInfo>> getInfo() override;
+    bool getResults(std::unordered_map<std::string, std::vector<StateResidency>> *results) override;
+    std::unordered_map<std::string, std::vector<StateInfo>> getInfo() override;
 
   private:
     const std::string mName;