Pixelstats: Add VendorSpeakerStatsReported to support Speaker Health

Add the new ATOM, VendorSpeakerStatsReported to support more speaker
health statistics.
 Eldar: 999001

Bug: 175736081
Test: Manually test.
Signed-off-by: Roger Fang <rogerfang@google.com>
Change-Id: I1542c51ba1f7776b8dcaff7d9c8e09b6f161f152

5 files changed, 147 insertions, 2 deletions

diff --git a/pixelstats/StatsHelper.cpp b/pixelstats/StatsHelper.cpp
index e41ef8ad..8fdb988e 100644
--- a/pixelstats/StatsHelper.cpp
+++ b/pixelstats/StatsHelper.cpp
@@ -67,6 +67,31 @@ void reportSpeakerImpedance(const std::shared_ptr<IStats> &stats_client,
         ALOGE("Unable to report VendorSpeakerImpedance to Stats service");
 }
 
+void reportSpeakerHealthStat(const std::shared_ptr<IStats> &stats_client,
+                             const PixelAtoms::VendorSpeakerStatsReported &speakerHealthStat) {
+    // Load values array
+    std::vector<VendorAtomValue> values(5);
+    VendorAtomValue tmp;
+    tmp.set<VendorAtomValue::intValue>(speakerHealthStat.speaker_location());
+    values[0] = tmp;
+    tmp.set<VendorAtomValue::intValue>(speakerHealthStat.impedance());
+    values[1] = tmp;
+    tmp.set<VendorAtomValue::intValue>(speakerHealthStat.max_temperature());
+    values[2] = tmp;
+    tmp.set<VendorAtomValue::intValue>(speakerHealthStat.excursion());
+    values[3] = tmp;
+    tmp.set<VendorAtomValue::intValue>(speakerHealthStat.heartbeat());
+    values[4] = tmp;
+
+    // Send vendor atom to IStats HAL
+    VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
+                        .atomId = PixelAtoms::Atom::kVendorSpeakerStatsReported,
+                        .values = std::move(values)};
+    const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event);
+    if (!ret.isOk())
+        ALOGE("Unable to report VendorSpeakerStatsReported to Stats service");
+}
+
 void reportSlowIo(const std::shared_ptr<IStats> &stats_client,
                   const PixelAtoms::VendorSlowIo &slowIo) {
     // Load values array
diff --git a/pixelstats/SysfsCollector.cpp b/pixelstats/SysfsCollector.cpp
index 8b002d02..520a564a 100644
--- a/pixelstats/SysfsCollector.cpp
+++ b/pixelstats/SysfsCollector.cpp
@@ -45,14 +45,15 @@ using android::base::WriteStringToFile;
 using android::hardware::google::pixel::PixelAtoms::BatteryCapacity;
 using android::hardware::google::pixel::PixelAtoms::BootStatsInfo;
 using android::hardware::google::pixel::PixelAtoms::F2fsCompressionInfo;
-using android::hardware::google::pixel::PixelAtoms::F2fsStatsInfo;
 using android::hardware::google::pixel::PixelAtoms::F2fsGcSegmentInfo;
+using android::hardware::google::pixel::PixelAtoms::F2fsStatsInfo;
 using android::hardware::google::pixel::PixelAtoms::StorageUfsHealth;
 using android::hardware::google::pixel::PixelAtoms::StorageUfsResetCount;
 using android::hardware::google::pixel::PixelAtoms::VendorChargeCycles;
 using android::hardware::google::pixel::PixelAtoms::VendorHardwareFailed;
 using android::hardware::google::pixel::PixelAtoms::VendorSlowIo;
 using android::hardware::google::pixel::PixelAtoms::VendorSpeakerImpedance;
+using android::hardware::google::pixel::PixelAtoms::VendorSpeakerStatsReported;
 using android::hardware::google::pixel::PixelAtoms::VendorSpeechDspStat;
 using android::hardware::google::pixel::PixelAtoms::ZramBdStat;
 using android::hardware::google::pixel::PixelAtoms::ZramMmStat;
@@ -77,7 +78,10 @@ SysfsCollector::SysfsCollector(const struct SysfsPaths &sysfs_paths)
       kZramMmStatPath("/sys/block/zram0/mm_stat"),
       kZramBdStatPath("/sys/block/zram0/bd_stat"),
       kEEPROMPath(sysfs_paths.EEPROMPath),
-      kPowerMitigationStatsPath(sysfs_paths.MitigationPath) {}
+      kPowerMitigationStatsPath(sysfs_paths.MitigationPath),
+      kSpeakerTemperaturePath(sysfs_paths.SpeakerTemperaturePath),
+      kSpeakerExcursionPath(sysfs_paths.SpeakerExcursionPath),
+      kSpeakerHeartbeatPath(sysfs_paths.SpeakerHeartBeatPath) {}
 
 bool SysfsCollector::ReadFileToInt(const std::string &path, int *val) {
     return ReadFileToInt(path.c_str(), val);
@@ -271,6 +275,91 @@ void SysfsCollector::logSpeakerImpedance(const std::shared_ptr<IStats> &stats_cl
 }
 
 /**
+ * Report the last-detected impedance, temperature and heartbeats of left & right speakers.
+ */
+void SysfsCollector::logSpeakerHealthStats(const std::shared_ptr<IStats> &stats_client) {
+    std::string file_contents;
+
+    if (kImpedancePath == nullptr || strlen(kImpedancePath) == 0) {
+        ALOGD("Audio impedance path not specified");
+        return;
+    }
+
+    if (kSpeakerTemperaturePath == nullptr || strlen(kSpeakerTemperaturePath) == 0) {
+        ALOGD("Audio speaker temperature path not specified");
+        return;
+    }
+
+    if (kSpeakerHeartbeatPath == nullptr || strlen(kSpeakerHeartbeatPath) == 0) {
+        ALOGD("Audio speaker heartbeat path not specified");
+        return;
+    }
+
+    if (kSpeakerExcursionPath == nullptr || strlen(kSpeakerExcursionPath) == 0) {
+        ALOGD("Audio speaker excursion path not specified");
+        return;
+    }
+
+    float left_impedance_ohm, right_impedance_ohm;
+
+    if (!ReadFileToString(kImpedancePath, &file_contents)) {
+        ALOGE("Unable to read speaker impedance path %s", kImpedancePath);
+        return;
+    }
+    if (sscanf(file_contents.c_str(), "%g,%g", &left_impedance_ohm, &right_impedance_ohm) != 2) {
+        ALOGE("Unable to parse speaker impedance %s", file_contents.c_str());
+        return;
+    }
+
+    float left_temperature_C, right_temperature_C;
+    if (!ReadFileToString(kSpeakerTemperaturePath, &file_contents)) {
+        ALOGE("Unable to read speaker temperature path %s", kSpeakerTemperaturePath);
+        return;
+    }
+    if (sscanf(file_contents.c_str(), "%g,%g", &left_temperature_C, &right_temperature_C) != 2) {
+        ALOGE("Unable to parse speaker temperature %s", file_contents.c_str());
+        return;
+    }
+
+    float left_excursion_mm, right_excursion_mm;
+    if (!ReadFileToString(kSpeakerExcursionPath, &file_contents)) {
+        ALOGE("Unable to read speaker excursion path %s", kSpeakerExcursionPath);
+        return;
+    }
+    if (sscanf(file_contents.c_str(), "%g,%g", &left_excursion_mm, &right_excursion_mm) != 2) {
+        ALOGE("Unable to parse speaker excursion %s", file_contents.c_str());
+        return;
+    }
+
+    float left_heartbeat, right_heartbeat;
+    if (!ReadFileToString(kSpeakerHeartbeatPath, &file_contents)) {
+        ALOGE("Unable to read speaker heartbeat path %s", kSpeakerHeartbeatPath);
+        return;
+    }
+    if (sscanf(file_contents.c_str(), "%g,%g", &left_heartbeat, &right_heartbeat) != 2) {
+        ALOGE("Unable to parse speaker heartbeat %s", file_contents.c_str());
+        return;
+    }
+
+    VendorSpeakerStatsReported left_obj;
+    left_obj.set_speaker_location(0);
+    left_obj.set_impedance(static_cast<int32_t>(left_impedance_ohm * 1000));
+    left_obj.set_max_temperature(static_cast<int32_t>(left_temperature_C * 1000));
+    left_obj.set_excursion(static_cast<int32_t>(left_excursion_mm * 1000));
+    left_obj.set_heartbeat(static_cast<int32_t>(left_heartbeat));
+
+    VendorSpeakerStatsReported right_obj;
+    right_obj.set_speaker_location(1);
+    right_obj.set_impedance(static_cast<int32_t>(right_impedance_ohm * 1000));
+    right_obj.set_max_temperature(static_cast<int32_t>(right_temperature_C * 1000));
+    right_obj.set_excursion(static_cast<int32_t>(right_excursion_mm * 1000));
+    right_obj.set_heartbeat(static_cast<int32_t>(right_heartbeat));
+
+    reportSpeakerHealthStat(stats_client, left_obj);
+    reportSpeakerHealthStat(stats_client, right_obj);
+}
+
+/**
  * Report the Speech DSP state.
  */
 void SysfsCollector::logSpeechDspStat(const std::shared_ptr<IStats> &stats_client) {
@@ -803,6 +892,7 @@ void SysfsCollector::logPerDay() {
     logUFSLifetime(stats_client);
     logUFSErrorStats(stats_client);
     logZramStats(stats_client);
+    logSpeakerHealthStats(stats_client);
     mm_metrics_reporter_.logCmaStatus(stats_client);
     mm_metrics_reporter_.logPixelMmMetricsPerDay(stats_client);
 }
diff --git a/pixelstats/include/pixelstats/StatsHelper.h b/pixelstats/include/pixelstats/StatsHelper.h
index b8a23902..7c79b6bf 100644
--- a/pixelstats/include/pixelstats/StatsHelper.h
+++ b/pixelstats/include/pixelstats/StatsHelper.h
@@ -50,6 +50,9 @@ void reportPhysicalDropDetected(const std::shared_ptr<IStats> &stats_client,
 void reportUsbPortOverheat(const std::shared_ptr<IStats> &stats_client,
                            const PixelAtoms::VendorUsbPortOverheat &overheat_info);
 
+void reportSpeakerHealthStat(const std::shared_ptr<IStats> &stats_client,
+                             const PixelAtoms::VendorSpeakerStatsReported &speakerHealthStat);
+
 }  // namespace pixel
 }  // namespace google
 }  // namespace hardware
diff --git a/pixelstats/include/pixelstats/SysfsCollector.h b/pixelstats/include/pixelstats/SysfsCollector.h
index 8045d4aa..2dcfea9b 100644
--- a/pixelstats/include/pixelstats/SysfsCollector.h
+++ b/pixelstats/include/pixelstats/SysfsCollector.h
@@ -55,6 +55,9 @@ class SysfsCollector {
         const char *const ZramBdStatPath;
         const char *const EEPROMPath;
         const char *const MitigationPath;
+        const char *const SpeakerTemperaturePath;
+        const char *const SpeakerExcursionPath;
+        const char *const SpeakerHeartBeatPath;
     };
 
     SysfsCollector(const struct SysfsPaths &paths);
@@ -81,6 +84,7 @@ class SysfsCollector {
     void logZramStats(const std::shared_ptr<IStats> &stats_client);
     void logBootStats(const std::shared_ptr<IStats> &stats_client);
     void logBatteryEEPROM(const std::shared_ptr<IStats> &stats_client);
+    void logSpeakerHealthStats(const std::shared_ptr<IStats> &stats_client);
 
     void reportSlowIoFromFile(const std::shared_ptr<IStats> &stats_client, const char *path,
                               const VendorSlowIo::IoOperation &operation_s);
@@ -108,6 +112,9 @@ class SysfsCollector {
     const char *const kZramBdStatPath;
     const char *const kEEPROMPath;
     const char *const kPowerMitigationStatsPath;
+    const char *const kSpeakerTemperaturePath;
+    const char *const kSpeakerExcursionPath;
+    const char *const kSpeakerHeartbeatPath;
 
     BatteryEEPROMReporter battery_EEPROM_reporter_;
     MmMetricsReporter mm_metrics_reporter_;
diff --git a/pixelstats/pixelatoms.proto b/pixelstats/pixelatoms.proto
index 1e6b0ebb..104f3799 100644
--- a/pixelstats/pixelatoms.proto
+++ b/pixelstats/pixelatoms.proto
@@ -68,6 +68,7 @@ message Atom {
 
       CitadelVersion citadel_version = 100018; // moved from vendor proprietary
       CitadelEvent citadel_event = 100019;  // moved from vendor proprietary
+      VendorSpeakerStatsReported vendor_speaker_stats_reported = 105030;
     }
     // AOSP atom ID range ends at 109999
 }
@@ -453,6 +454,25 @@ message CitadelVersion {
     optional int32 impedance = 3;
 }
 
+/**
+ * Logs the reported vendor speaker health stats.
+ * Logged from: hardware/google/pixel/pixelstats/SysfsCollector.cpp
+ */
+message VendorSpeakerStatsReported {
+  /* Vendor reverse domain name (expecting "com.google.pixel") */
+  optional string reverse_domain_name = 1;
+  /* The location of speaker; 0 = left , 1 = right */
+  optional int32 speaker_location = 2;
+  /* The speaker's impedance value (milliOhm) */
+  optional int32 impedance = 3;
+  /* The speaker's maximum temperature (milliDegree C) */
+  optional int32 max_temperature = 4;
+  /* The speaker's execursion length (micrometer) */
+  optional int32 excursion = 5;
+  /* The speaker's heart beat count */
+  optional int32 heartbeat = 6;
+}
+
 /* A message containing how many times of ufs host reset */
 message StorageUfsResetCount {
     optional string reverse_domain_name = 1;