File indexing completed on 2024-05-12 05:30:13

 /*
     SPDX-FileCopyrightText: 2020 David Edmundson <davidedmundson@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 */
 
 #include <QCoreApplication>
 #include <QDebug>
 
 #include <QDBusConnection>
 #include <QDBusMetaType>
 
 #include <QCommandLineParser>
 
 #include <iostream>
 
 #include <formatter/Formatter.h>
 #include <systemstats/DBusInterface.h>
 
 class SensorWatcher : public QCoreApplication
 {
     Q_OBJECT
 
 public:
     SensorWatcher(int &argc, char **argv);
     ~SensorWatcher() = default;
 
     void subscribe(const QStringList &sensorNames);
     void list();
     void showDetails(const QStringList &sensorNames);
 
     void setShowDetails(bool details);
     void setRemain(bool remain);
 
 private:
     void onNewSensorData(const KSysGuard::SensorDataList &changes);
     void onSensorMetaDataChanged(const KSysGuard::SensorInfoMap &sensors);
     void showSensorDetails(const KSysGuard::SensorInfoMap &sensors);
     KSysGuard::SystemStats::DBusInterface *m_iface;
     /// Contains the names of all sensors that have **not** reported any data yet
     QSet<QString> m_unreportedSensors;
     bool m_showDetails = false;
     /// When @c true, remain connected; otherwise, exit as soon as all subscribed sensors have reported data
     bool m_remain = false;
 };
 
 int main(int argc, char **argv)
 {
     qDBusRegisterMetaType<KSysGuard::SensorData>();
     qDBusRegisterMetaType<KSysGuard::SensorInfo>();
     qDBusRegisterMetaType<KSysGuard::SensorDataList>();
     qDBusRegisterMetaType<QHash<QString, KSysGuard::SensorInfo>>();
     qDBusRegisterMetaType<QStringList>();
 
     SensorWatcher app(argc, argv);
 
     QCommandLineParser parser;
     parser.addOption({ QStringLiteral("list"), QStringLiteral("List Available Sensors") });
     parser.addOption({ QStringLiteral("details"), QStringLiteral("Show detailed information about selected sensors") });
     parser.addOption({ QStringLiteral("remain"), QStringLiteral("Do not exit, but keep reporting sensor values") });
 
     parser.addPositionalArgument(QStringLiteral("sensorNames"), QStringLiteral("List of sensors to monitor"), QStringLiteral("sensorId1 sensorId2  ..."));
     parser.addHelpOption();
     parser.process(app);
 
     if (parser.isSet(QStringLiteral("list"))) {
         app.list();
     } else if (parser.positionalArguments().isEmpty()) {
         qDebug() << "No sensors specified.";
         parser.showHelp(-1);
     } else {
         app.setShowDetails(parser.isSet(QStringLiteral("details")));
         app.setRemain(parser.isSet(QStringLiteral("remain")));
         app.subscribe(parser.positionalArguments());
         app.exec();
     }
 }
 
 SensorWatcher::SensorWatcher(int &argc, char **argv)
     : QCoreApplication(argc, argv)
     , m_iface(new KSysGuard::SystemStats::DBusInterface(KSysGuard::SystemStats::ServiceName,
           KSysGuard::SystemStats::ObjectPath,
           QDBusConnection::sessionBus(),
           this))
 {
     connect(m_iface, &KSysGuard::SystemStats::DBusInterface::newSensorData, this, &SensorWatcher::onNewSensorData);
     connect(m_iface, &KSysGuard::SystemStats::DBusInterface::sensorMetaDataChanged, this, &SensorWatcher::onSensorMetaDataChanged);
 }
 
 void SensorWatcher::subscribe(const QStringList &sensorNames)
 {
     m_iface->subscribe(sensorNames);
 
     m_unreportedSensors = QSet<QString>(sensorNames.begin(), sensorNames.end());
     auto pendingInitialValues = m_iface->sensorData(sensorNames);
     pendingInitialValues.waitForFinished();
     onNewSensorData(pendingInitialValues.value());
 
     if (!m_remain && !m_unreportedSensors.isEmpty()) {
         // We want to do one pass only, and there are sensors that
         // have no initial data. That **might** be because they
         // are mis-spelled, so go through all the sensors and
         // check that the names are ok; sensors that do not exist
         // will be removed (and get a complaining message, too).
         QSet<QString> existingSensors;
         // Fill the set of existing sensor names
         {
             auto pendingSensors = m_iface->allSensors();
             pendingSensors.waitForFinished();
             const auto allSensors = pendingSensors.value();
             for (auto it = allSensors.constBegin(); it != allSensors.constEnd(); it++) {
                 existingSensors.insert(it.key());
             }
         }
 
         QSet<QString> nonexistentSensors;
         for (const auto& sensorName : std::as_const(m_unreportedSensors)) {
             if (!existingSensors.contains(sensorName)) {
                 // This sensor (named on the command-line, and with no data so far) does not exist
                 std::cout << "No sensor named '" << qPrintable(sensorName) << "'\n";
                 nonexistentSensors.insert(sensorName);
             }
         }
         m_unreportedSensors.subtract(nonexistentSensors);
     }
 
     if (m_showDetails) {
         auto pendingSensors = m_iface->sensors(sensorNames);
         pendingSensors.waitForFinished();
 
         auto sensors = pendingSensors.value();
         showSensorDetails(sensors);
     }
 
     if (!m_remain && m_unreportedSensors.isEmpty())
     {
         QTimer::singleShot(0, this, &QCoreApplication::quit);
     }
 }
 
 void SensorWatcher::onNewSensorData(const KSysGuard::SensorDataList &changes)
 {
     for (const auto &entry : changes) {
         std::cout << qPrintable(entry.sensorProperty) << ' ' << qPrintable(entry.payload.toString()) << std::endl;
         m_unreportedSensors.remove(entry.sensorProperty);
     }
     // Use a timer so that we get out of this slot first; since this is **also** called
     // from subscribe, we want to let that function complete too, just in case the user
     // has asked for details.
     if (!m_remain && m_unreportedSensors.isEmpty())
     {
         QTimer::singleShot(0, this, &QCoreApplication::quit);
     }
 }
 
 void SensorWatcher::onSensorMetaDataChanged(const KSysGuard::SensorInfoMap &sensors)
 {
     if (!m_showDetails) {
         return;
     }
 
     std::cout << "Sensor metadata changed\n";
     showSensorDetails(sensors);
 }
 
 void SensorWatcher::list()
 {
     auto pendingSensors = m_iface->allSensors();
     pendingSensors.waitForFinished();
     auto sensors = pendingSensors.value();
     if (sensors.count() < 1) {
         std::cout << "No sensors available.";
     }
     for (auto it = sensors.constBegin(); it != sensors.constEnd(); it++) {
         std::cout << qPrintable(it.key()) << ' ' << qPrintable(it.value().name) << std::endl;
     }
 }
 
 void SensorWatcher::setShowDetails(bool details)
 {
     m_showDetails = details;
 }
 
 void SensorWatcher::setRemain(bool remain)
 {
     m_remain = remain;
 }
 
 void SensorWatcher::showSensorDetails(const KSysGuard::SensorInfoMap &sensors)
 {
     for (auto it = sensors.constBegin(); it != sensors.constEnd(); ++it) {
         auto info = it.value();
         std::cout << qPrintable(it.key()) << "\n";
         std::cout << "    Name:        " << qPrintable(info.name) << "\n";
         std::cout << "    Short Name:  " << qPrintable(info.shortName) << "\n";
         std::cout << "    Description: " << qPrintable(info.description) << "\n";
         std::cout << "    Unit:        " << qPrintable(KSysGuard::Formatter::symbol(info.unit)) << "\n";
         std::cout << "    Minimum:     " << info.min << "\n";
         std::cout << "    Maximum:     " << info.max << "\n";
     }
 }
 
 #include "main.moc"