powerstats: Clean up PowerStats HAL 2.0 impl

Bug: 169864180
Test: dumpsys android.hardware.powerstats.IPowerStats/default
Change-Id: Ia067e46ba166e4fee30a2b871ea60332546a178c

11 files changed, 92 insertions, 88 deletions

diff --git a/powerstats/Android.bp b/powerstats/Android.bp
index 848def16..9d60fe31 100644
--- a/powerstats/Android.bp
+++ b/powerstats/Android.bp
@@ -34,7 +34,7 @@ cc_library {
     srcs: [
         "dataproviders/DisplayStateResidencyDataProvider.cpp",
         "dataproviders/GenericStateResidencyDataProvider.cpp",
-        "dataproviders/IioRailEnergyDataProvider.cpp",
+        "dataproviders/IioEnergyMeterDataProvider.cpp",
         "dataproviders/WlanStateResidencyDataProvider.cpp",
         "PowerStatsAidl.cpp",
     ],
diff --git a/powerstats/PowerStatsAidl.cpp b/powerstats/PowerStatsAidl.cpp
index 086a6488..561ed537 100644
--- a/powerstats/PowerStatsAidl.cpp
+++ b/powerstats/PowerStatsAidl.cpp
@@ -54,14 +54,13 @@ ndk::ScopedAStatus PowerStats::getPowerEntityInfo(std::vector<PowerEntityInfo> *
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus PowerStats::getPowerEntityStateResidency(
-        const std::vector<int32_t> &in_powerEntityIds,
-        std::vector<StateResidencyResult> *_aidl_return) {
+ndk::ScopedAStatus PowerStats::getStateResidency(const std::vector<int32_t> &in_powerEntityIds,
+                                                 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 getPowerEntityStateResidency(v, _aidl_return);
+        return getStateResidency(v, _aidl_return);
     }
 
     binder_status_t err = STATUS_OK;
@@ -78,7 +77,7 @@ ndk::ScopedAStatus PowerStats::getPowerEntityStateResidency(
         // Check to see if we already have data for the given id
         std::string powerEntityName = mPowerEntityInfos[id].powerEntityName;
         if (stateResidencies.find(powerEntityName) == stateResidencies.end()) {
-            mStateResidencyDataProviders[id]->getResults(&stateResidencies);
+            mStateResidencyDataProviders[id]->getStateResidencies(&stateResidencies);
         }
 
         // Append results if we have them
@@ -114,26 +113,26 @@ ndk::ScopedAStatus PowerStats::getEnergyConsumed(
     return ndk::ScopedAStatus::ok();
 }
 
-void PowerStats::setRailDataProvider(std::unique_ptr<IRailEnergyDataProvider> p) {
-    mRailEnergyDataProvider = std::move(p);
+void PowerStats::setEnergyMeterDataProvider(std::unique_ptr<IEnergyMeterDataProvider> p) {
+    mEnergyMeterDataProvider = std::move(p);
 }
 
 ndk::ScopedAStatus PowerStats::getEnergyMeterInfo(std::vector<ChannelInfo> *_aidl_return) {
-    if (!mRailEnergyDataProvider) {
+    if (!mEnergyMeterDataProvider) {
         return ndk::ScopedAStatus::ok();
     }
-    return mRailEnergyDataProvider->getRailInfo(_aidl_return);
+    return mEnergyMeterDataProvider->getEnergyMeterInfo(_aidl_return);
 }
 
 ndk::ScopedAStatus PowerStats::readEnergyMeters(const std::vector<int32_t> &in_channelIds,
                                                 std::vector<EnergyMeasurement> *_aidl_return) {
-    if (!mRailEnergyDataProvider) {
+    if (!mEnergyMeterDataProvider) {
         return ndk::ScopedAStatus::ok();
     }
-    return mRailEnergyDataProvider->getRailEnergy(in_channelIds, _aidl_return);
+    return mEnergyMeterDataProvider->readEnergyMeters(in_channelIds, _aidl_return);
 }
 
-void PowerStats::getEntityStateMaps(
+void PowerStats::getEntityStateNames(
         std::unordered_map<int32_t, std::string> *entityNames,
         std::unordered_map<int32_t, std::unordered_map<int32_t, std::string>> *stateNames) {
     std::vector<PowerEntityInfo> infos;
@@ -149,25 +148,25 @@ void PowerStats::getEntityStateMaps(
     }
 }
 
-void PowerStats::getRailEnergyMaps(std::unordered_map<int32_t, std::string> *railNames) {
+void PowerStats::getChannelNames(std::unordered_map<int32_t, std::string> *channelNames) {
     std::vector<ChannelInfo> infos;
     getEnergyMeterInfo(&infos);
 
     for (const auto &info : infos) {
-        railNames->emplace(info.channelId, info.channelName);
+        channelNames->emplace(info.channelId, info.channelName);
     }
 }
 
-void PowerStats::dumpRailEnergy(std::ostringstream &oss, bool delta) {
+void PowerStats::dumpEnergyMeter(std::ostringstream &oss, bool delta) {
     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::string> railNames;
-    getRailEnergyMaps(&railNames);
+    std::unordered_map<int32_t, std::string> channelNames;
+    getChannelNames(&channelNames);
 
-    oss << "\n============= PowerStats HAL 2.0 rail energy ==============\n";
+    oss << "\n============= PowerStats HAL 2.0 energy meter ==============\n";
 
     std::vector<EnergyMeasurement> energyData;
     readEnergyMeters({}, &energyData);
@@ -181,7 +180,7 @@ void PowerStats::dumpRailEnergy(std::ostringstream &oss, bool delta) {
             << std::chrono::duration_cast<std::chrono::milliseconds>(curTime - prevTime).count()
             << " ms";
 
-        oss << ::android::base::StringPrintf(headerFormatDelta, "Rail", "Cumulative Energy",
+        oss << ::android::base::StringPrintf(headerFormatDelta, "Channel", "Cumulative Energy",
                                              "Delta   ");
 
         std::unordered_map<int32_t, int64_t> prevEnergyDataMap;
@@ -197,7 +196,7 @@ void PowerStats::dumpRailEnergy(std::ostringstream &oss, bool delta) {
             }
 
             oss << ::android::base::StringPrintf(dataFormatDelta,
-                                                 railNames.at(data.channelId).c_str(),
+                                                 channelNames.at(data.channelId).c_str(),
                                                  static_cast<float>(data.energyUWs) / 1000.0,
                                                  static_cast<float>(deltaEnergy) / 1000.0);
         }
@@ -205,15 +204,16 @@ void PowerStats::dumpRailEnergy(std::ostringstream &oss, bool delta) {
         prevEnergyData = energyData;
         prevTime = curTime;
     } else {
-        oss << ::android::base::StringPrintf(headerFormat, "Rail", "Cumulative Energy");
+        oss << ::android::base::StringPrintf(headerFormat, "Channel", "Cumulative Energy");
 
         for (const auto &data : energyData) {
-            oss << ::android::base::StringPrintf(dataFormat, railNames.at(data.channelId).c_str(),
+            oss << ::android::base::StringPrintf(dataFormat,
+                                                 channelNames.at(data.channelId).c_str(),
                                                  static_cast<float>(data.energyUWs) / 1000.0);
         }
     }
 
-    oss << "========== End of PowerStats HAL 2.0 rail energy ==========\n";
+    oss << "========== End of PowerStats HAL 2.0 energy meter ==========\n";
 }
 
 void PowerStats::dumpStateResidency(std::ostringstream &oss, bool delta) {
@@ -227,12 +227,12 @@ void PowerStats::dumpStateResidency(std::ostringstream &oss, bool delta) {
     // Construct maps to entity and state names
     std::unordered_map<int32_t, std::string> entityNames;
     std::unordered_map<int32_t, std::unordered_map<int32_t, std::string>> stateNames;
-    getEntityStateMaps(&entityNames, &stateNames);
+    getEntityStateNames(&entityNames, &stateNames);
 
     oss << "\n============= PowerStats HAL 2.0 state residencies ==============\n";
 
     std::vector<StateResidencyResult> results;
-    getPowerEntityStateResidency({}, &results);
+    getStateResidency({}, &results);
 
     if (delta) {
         static std::vector<StateResidencyResult> prevResults;
@@ -323,8 +323,8 @@ binder_status_t PowerStats::dump(int fd, const char **args, uint32_t numArgs) {
     // Generate debug output for state residency
     dumpStateResidency(oss, delta);
 
-    // Generate debug output for rail energy
-    dumpRailEnergy(oss, delta);
+    // Generate debug output energy meter
+    dumpEnergyMeter(oss, delta);
 
     ::android::base::WriteStringToFd(oss.str(), fd);
     fsync(fd);
diff --git a/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp b/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp
index 1b63c025..12f605f9 100644
--- a/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp
+++ b/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp
@@ -70,8 +70,8 @@ DisplayStateResidencyDataProvider::~DisplayStateResidencyDataProvider() {
     }
 }
 
-bool DisplayStateResidencyDataProvider::getResults(
-        std::unordered_map<std::string, std::vector<StateResidency>> *results) {
+bool DisplayStateResidencyDataProvider::getStateResidencies(
+        std::unordered_map<std::string, std::vector<StateResidency>> *residencies) {
     std::scoped_lock lk(mLock);
 
     // Get current time since boot in milliseconds
@@ -82,7 +82,7 @@ bool DisplayStateResidencyDataProvider::getResults(
     // Construct residency result based on current residency data
     auto result = mResidencies;
     result[mCurState].totalTimeInStateMs += now - result[mCurState].lastEntryTimestampMs;
-    results->emplace(mName, result);
+    residencies->emplace(mName, result);
     return true;
 }
 
diff --git a/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp b/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp
index ca5ff431..fa9faeba 100644
--- a/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp
+++ b/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp
@@ -142,8 +142,8 @@ static bool getStateData(std::vector<StateResidency> *result,
     return true;
 }
 
-bool GenericStateResidencyDataProvider::getResults(
-        std::unordered_map<std::string, std::vector<StateResidency>> *results) {
+bool GenericStateResidencyDataProvider::getStateResidencies(
+        std::unordered_map<std::string, std::vector<StateResidency>> *residencies) {
     // Using FILE* instead of std::ifstream for performance reasons
     std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(mPath.c_str(), "r"), fclose);
     if (!fp) {
@@ -169,7 +169,7 @@ bool GenericStateResidencyDataProvider::getResults(
         std::vector<StateResidency> result;
         if (getStateData(&result, mPowerEntityConfigs[nextConfig].mStateResidencyConfigs, fp.get(),
                          &line, &len)) {
-            results->emplace(mPowerEntityConfigs[nextConfig].mName, result);
+            residencies->emplace(mPowerEntityConfigs[nextConfig].mName, result);
             ++numEntitiesRead;
         } else {
             break;
diff --git a/powerstats/dataproviders/IioRailEnergyDataProvider.cpp b/powerstats/dataproviders/IioEnergyMeterDataProvider.cpp
index 3056af0e..fa459eef 100644
--- a/powerstats/dataproviders/IioRailEnergyDataProvider.cpp
+++ b/powerstats/dataproviders/IioEnergyMeterDataProvider.cpp
@@ -16,7 +16,7 @@
 
 #define LOG_TAG "android.hardware.powerstats-service.pixel"
 
-#include <dataproviders/IioRailEnergyDataProvider.h>
+#include <dataproviders/IioEnergyMeterDataProvider.h>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -28,7 +28,7 @@ namespace android {
 namespace hardware {
 namespace powerstats {
 
-void IioRailEnergyDataProvider::findIioPowerMonitorNodes() {
+void IioEnergyMeterDataProvider::findIioEnergyMeterNodes() {
     struct dirent *ent;
     DIR *iioDir = opendir(kIioRootDir.c_str());
     if (!iioDir) {
@@ -54,7 +54,7 @@ void IioRailEnergyDataProvider::findIioPowerMonitorNodes() {
     return;
 }
 
-void IioRailEnergyDataProvider::parsePowerRails() {
+void IioEnergyMeterDataProvider::parseEnabledRails() {
     std::string data;
     int32_t id = 0;
     for (const auto &path : mDevicePaths) {
@@ -78,8 +78,8 @@ void IioRailEnergyDataProvider::parsePowerRails() {
         while (std::getline(railNames, line)) {
             std::vector<std::string> words = ::android::base::Split(line, ":");
             if (words.size() == 2) {
-                mRailInfos.push_back({.channelId = id, .channelName = words[0]});
-                mRailIds.emplace(words[0], id);
+                mChannelInfos.push_back({.channelId = id, .channelName = words[0]});
+                mChannelIds.emplace(words[0], id);
                 id++;
             } else {
                 LOG(WARNING) << "Unexpected enabled rail format in " << path;
@@ -88,14 +88,14 @@ void IioRailEnergyDataProvider::parsePowerRails() {
     }
 }
 
-IioRailEnergyDataProvider::IioRailEnergyDataProvider(const std::string &deviceName)
+IioEnergyMeterDataProvider::IioEnergyMeterDataProvider(const std::string &deviceName)
     : kDeviceName(std::move(deviceName)) {
-    findIioPowerMonitorNodes();
-    parsePowerRails();
-    mReading.resize(mRailInfos.size());
+    findIioEnergyMeterNodes();
+    parseEnabledRails();
+    mReading.resize(mChannelInfos.size());
 }
 
-int IioRailEnergyDataProvider::parseIioEnergyNode(std::string path) {
+int IioEnergyMeterDataProvider::parseEnergyValue(std::string path) {
     int ret = 0;
     std::string data;
     if (!::android::base::ReadFileToString(path + kEnergyValueNode, &data)) {
@@ -119,8 +119,8 @@ int IioRailEnergyDataProvider::parseIioEnergyNode(std::string path) {
             }
         } else if (words.size() == 2) {
             std::string railName = words[0];
-            if (mRailIds.count(railName) != 0) {
-                size_t id = mRailIds[railName];
+            if (mChannelIds.count(railName) != 0) {
+                size_t id = mChannelIds[railName];
                 mReading[id].channelId = id;
                 mReading[id].timestampMs = timestamp;
                 mReading[id].energyUWs = std::stoull(words[1]);
@@ -137,24 +137,24 @@ int IioRailEnergyDataProvider::parseIioEnergyNode(std::string path) {
     return ret;
 }
 
-ndk::ScopedAStatus IioRailEnergyDataProvider::getRailEnergy(
-        const std::vector<int32_t> &in_railIds, std::vector<EnergyMeasurement> *_aidl_return) {
+ndk::ScopedAStatus IioEnergyMeterDataProvider::readEnergyMeters(
+        const std::vector<int32_t> &in_channelIds, std::vector<EnergyMeasurement> *_aidl_return) {
     std::scoped_lock lock(mLock);
     binder_status_t ret = STATUS_OK;
     for (const auto &devicePath : mDevicePaths) {
-        if (parseIioEnergyNode(devicePath) < 0) {
+        if (parseEnergyValue(devicePath) < 0) {
             LOG(ERROR) << "Error in parsing " << devicePath;
             return ndk::ScopedAStatus::fromStatus(STATUS_FAILED_TRANSACTION);
         }
     }
 
-    if (in_railIds.empty()) {
+    if (in_channelIds.empty()) {
         *_aidl_return = mReading;
     } else {
-        _aidl_return->reserve(in_railIds.size());
-        for (const auto &railId : in_railIds) {
-            if (railId < mRailInfos.size()) {
-                _aidl_return->emplace_back(mReading[railId]);
+        _aidl_return->reserve(in_channelIds.size());
+        for (const auto &channelId : in_channelIds) {
+            if (channelId < mChannelInfos.size()) {
+                _aidl_return->emplace_back(mReading[channelId]);
             } else {
                 ret = STATUS_BAD_VALUE;
             }
@@ -163,9 +163,10 @@ ndk::ScopedAStatus IioRailEnergyDataProvider::getRailEnergy(
     return ndk::ScopedAStatus::fromStatus(ret);
 }
 
-ndk::ScopedAStatus IioRailEnergyDataProvider::getRailInfo(std::vector<ChannelInfo> *_aidl_return) {
+ndk::ScopedAStatus IioEnergyMeterDataProvider::getEnergyMeterInfo(
+        std::vector<ChannelInfo> *_aidl_return) {
     std::scoped_lock lk(mLock);
-    *_aidl_return = mRailInfos;
+    *_aidl_return = mChannelInfos;
     return ndk::ScopedAStatus::ok();
 }
 
diff --git a/powerstats/dataproviders/WlanStateResidencyDataProvider.cpp b/powerstats/dataproviders/WlanStateResidencyDataProvider.cpp
index a148015f..061f05cc 100644
--- a/powerstats/dataproviders/WlanStateResidencyDataProvider.cpp
+++ b/powerstats/dataproviders/WlanStateResidencyDataProvider.cpp
@@ -43,15 +43,15 @@ static bool extractStat(const char *line, const std::string &prefix, uint64_t *s
     return true;
 }
 
-bool WlanStateResidencyDataProvider::getResults(
-        std::unordered_map<std::string, std::vector<StateResidency>> *results) {
+bool WlanStateResidencyDataProvider::getStateResidencies(
+        std::unordered_map<std::string, std::vector<StateResidency>> *residencies) {
     std::vector<StateResidency> result = {{.stateId = ACTIVE_ID}, {.stateId = DEEPSLEEP_ID}};
 
     std::string wlanDriverStatus = ::android::base::GetProperty("wlan.driver.status", "unloaded");
     if (wlanDriverStatus != "ok") {
         LOG(ERROR) << ": wlan is " << wlanDriverStatus;
         // Return 0s for Wlan stats, because the driver is unloaded
-        results->emplace(mName, result);
+        residencies->emplace(mName, result);
         return true;
     }
 
@@ -93,7 +93,7 @@ bool WlanStateResidencyDataProvider::getResults(
         return false;
     }
 
-    results->emplace(mName, result);
+    residencies->emplace(mName, result);
 
     return true;
 }
diff --git a/powerstats/include/PowerStatsAidl.h b/powerstats/include/PowerStatsAidl.h
index ea3488ea..669994c6 100644
--- a/powerstats/include/PowerStatsAidl.h
+++ b/powerstats/include/PowerStatsAidl.h
@@ -34,28 +34,28 @@ class PowerStats : public BnPowerStats {
     class IStateResidencyDataProvider : public virtual ::android::RefBase {
       public:
         virtual ~IStateResidencyDataProvider() = default;
-        virtual bool getResults(
-                std::unordered_map<std::string, std::vector<StateResidency>> *results) = 0;
+        virtual bool getStateResidencies(
+                std::unordered_map<std::string, std::vector<StateResidency>> *residencies) = 0;
         virtual std::unordered_map<std::string, std::vector<StateInfo>> getInfo() = 0;
     };
 
-    class IRailEnergyDataProvider {
+    class IEnergyMeterDataProvider {
       public:
-        virtual ~IRailEnergyDataProvider() = default;
-        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;
+        virtual ~IEnergyMeterDataProvider() = default;
+        virtual ndk::ScopedAStatus readEnergyMeters(
+                const std::vector<int32_t> &in_channelIds,
+                std::vector<EnergyMeasurement> *_aidl_return) = 0;
+        virtual ndk::ScopedAStatus getEnergyMeterInfo(std::vector<ChannelInfo> *_aidl_return) = 0;
     };
 
     PowerStats() = default;
-    void setRailDataProvider(std::unique_ptr<IRailEnergyDataProvider> p);
+    void setEnergyMeterDataProvider(std::unique_ptr<IEnergyMeterDataProvider> p);
     void addStateResidencyDataProvider(sp<IStateResidencyDataProvider> p);
 
     // Methods from aidl::android::hardware::powerstats::IPowerStats
     ndk::ScopedAStatus getPowerEntityInfo(std::vector<PowerEntityInfo> *_aidl_return) override;
-    ndk::ScopedAStatus getPowerEntityStateResidency(
-            const std::vector<int32_t> &in_powerEntityIds,
-            std::vector<StateResidencyResult> *_aidl_return) override;
+    ndk::ScopedAStatus getStateResidency(const std::vector<int32_t> &in_powerEntityIds,
+                                         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;
@@ -65,21 +65,21 @@ class PowerStats : public BnPowerStats {
     binder_status_t dump(int fd, const char **args, uint32_t numArgs) override;
 
   private:
-    void getEntityStateMaps(
+    void getEntityStateNames(
             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::string> *railNames);
+    void getChannelNames(std::unordered_map<int32_t, std::string> *channelNames);
     void dumpStateResidency(std::ostringstream &oss, bool delta);
     void dumpStateResidencyDelta(std::ostringstream &oss,
                                  const std::vector<StateResidencyResult> &results);
     void dumpStateResidencyOneShot(std::ostringstream &oss,
                                    const std::vector<StateResidencyResult> &results);
-    void dumpRailEnergy(std::ostringstream &oss, bool delta);
+    void dumpEnergyMeter(std::ostringstream &oss, bool delta);
 
     std::vector<sp<IStateResidencyDataProvider>> mStateResidencyDataProviders;
     std::vector<PowerEntityInfo> mPowerEntityInfos;
 
-    std::unique_ptr<IRailEnergyDataProvider> mRailEnergyDataProvider;
+    std::unique_ptr<IEnergyMeterDataProvider> mEnergyMeterDataProvider;
 };
 
 }  // namespace powerstats
diff --git a/powerstats/include/dataproviders/DisplayStateResidencyDataProvider.h b/powerstats/include/dataproviders/DisplayStateResidencyDataProvider.h
index 48a317bf..29b67542 100644
--- a/powerstats/include/dataproviders/DisplayStateResidencyDataProvider.h
+++ b/powerstats/include/dataproviders/DisplayStateResidencyDataProvider.h
@@ -43,7 +43,8 @@ class DisplayStateResidencyDataProvider : public PowerStats::IStateResidencyData
     ~DisplayStateResidencyDataProvider();
 
     // Methods from PowerStats::IStateResidencyDataProvider
-    bool getResults(std::unordered_map<std::string, std::vector<StateResidency>> *results) override;
+    bool getStateResidencies(
+            std::unordered_map<std::string, std::vector<StateResidency>> *residencies) override;
     std::unordered_map<std::string, std::vector<StateInfo>> getInfo() override;
 
   private:
diff --git a/powerstats/include/dataproviders/GenericStateResidencyDataProvider.h b/powerstats/include/dataproviders/GenericStateResidencyDataProvider.h
index aee87d6d..d6601e07 100644
--- a/powerstats/include/dataproviders/GenericStateResidencyDataProvider.h
+++ b/powerstats/include/dataproviders/GenericStateResidencyDataProvider.h
@@ -61,7 +61,8 @@ class GenericStateResidencyDataProvider : public PowerStats::IStateResidencyData
     ~GenericStateResidencyDataProvider() = default;
 
     // Methods from PowerStats::IStateResidencyDataProvider
-    bool getResults(std::unordered_map<std::string, std::vector<StateResidency>> *results) override;
+    bool getStateResidencies(
+            std::unordered_map<std::string, std::vector<StateResidency>> *residencies) override;
     std::unordered_map<std::string, std::vector<StateInfo>> getInfo() override;
 
   private:
diff --git a/powerstats/include/dataproviders/IioRailEnergyDataProvider.h b/powerstats/include/dataproviders/IioEnergyMeterDataProvider.h
index 06d49263..b2aaefd5 100644
--- a/powerstats/include/dataproviders/IioRailEnergyDataProvider.h
+++ b/powerstats/include/dataproviders/IioEnergyMeterDataProvider.h
@@ -25,24 +25,24 @@ namespace android {
 namespace hardware {
 namespace powerstats {
 
-class IioRailEnergyDataProvider : public PowerStats::IRailEnergyDataProvider {
+class IioEnergyMeterDataProvider : public PowerStats::IEnergyMeterDataProvider {
   public:
-    IioRailEnergyDataProvider(const std::string &deviceName);
+    IioEnergyMeterDataProvider(const std::string &deviceName);
 
     // Methods from PowerStats::IRailEnergyDataProvider
-    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;
+    ndk::ScopedAStatus readEnergyMeters(const std::vector<int32_t> &in_channelIds,
+                                        std::vector<EnergyMeasurement> *_aidl_return) override;
+    ndk::ScopedAStatus getEnergyMeterInfo(std::vector<ChannelInfo> *_aidl_return) override;
 
   private:
-    void findIioPowerMonitorNodes();
-    void parsePowerRails();
-    int parseIioEnergyNode(std::string path);
+    void findIioEnergyMeterNodes();
+    void parseEnabledRails();
+    int parseEnergyValue(std::string path);
 
     std::mutex mLock;
     std::vector<std::string> mDevicePaths;
-    std::unordered_map<std::string, int32_t> mRailIds;  // key: name, value: id
-    std::vector<ChannelInfo> mRailInfos;
+    std::unordered_map<std::string, int32_t> mChannelIds;  // key: name, value: id
+    std::vector<ChannelInfo> mChannelInfos;
     std::vector<EnergyMeasurement> mReading;
 
     const std::string kDeviceName;
diff --git a/powerstats/include/dataproviders/WlanStateResidencyDataProvider.h b/powerstats/include/dataproviders/WlanStateResidencyDataProvider.h
index 64f2a18b..8dad8a3d 100644
--- a/powerstats/include/dataproviders/WlanStateResidencyDataProvider.h
+++ b/powerstats/include/dataproviders/WlanStateResidencyDataProvider.h
@@ -30,7 +30,8 @@ class WlanStateResidencyDataProvider : public PowerStats::IStateResidencyDataPro
     ~WlanStateResidencyDataProvider() = default;
 
     // Methods from PowerStats::IStateResidencyDataProvider
-    bool getResults(std::unordered_map<std::string, std::vector<StateResidency>> *results) override;
+    bool getStateResidencies(
+            std::unordered_map<std::string, std::vector<StateResidency>> *residencies) override;
     std::unordered_map<std::string, std::vector<StateInfo>> getInfo() override;
 
   private: