File indexing completed on 2024-12-15 03:45:04

 /*
     SPDX-FileCopyrightText: 2016 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: MIT
 */
 
 #include "propertyratiosource.h"
 #include "abstractdatasource_p.h"
 #include "logging_p.h"
 
 #include <QDebug>
 #include <QHash>
 #include <QMap>
 #include <QMetaProperty>
 #include <QObject>
 #include <QPointer>
 #include <QSettings>
 #include <QStringList>
 #include <QTime>
 #include <QElapsedTimer>
 
 using namespace KUserFeedback;
 
 namespace KUserFeedback {
 class PropertyRatioSourcePrivate : public AbstractDataSourcePrivate
 {
 public:
     PropertyRatioSourcePrivate();
     ~PropertyRatioSourcePrivate() override;
 
     void propertyChanged();
     QString valueToString(const QVariant &value) const;
     void trySetup();
 
     QString name;
     QString description;
     QPointer<QObject> obj;
     QByteArray propertyName;
     QObject *signalMonitor;
     QMetaProperty property;
     QString previousValue;
     QElapsedTimer lastChangeTime;
     QHash<QString, int> ratioSet; // data we are currently tracking
     QHash<QString, int> baseRatioSet; // data loaded from storage
     QList<QPair<QVariant, QString>> valueMap;
 };
 
 // inefficient workaround for not being able to connect QMetaMethod to a function directly
 class SignalMonitor : public QObject
 {
     Q_OBJECT
 public:
     explicit SignalMonitor(PropertyRatioSourcePrivate *r) : m_receiver(r) {}
 public Q_SLOTS:
     void propertyChanged()
     {
         m_receiver->propertyChanged();
     }
 private:
     PropertyRatioSourcePrivate *m_receiver;
 };
 
 }
 
 PropertyRatioSourcePrivate::PropertyRatioSourcePrivate()
     : obj(nullptr)
     , signalMonitor(nullptr)
 {
 }
 
 PropertyRatioSourcePrivate::~PropertyRatioSourcePrivate()
 {
     delete signalMonitor;
 }
 
 void PropertyRatioSourcePrivate::propertyChanged()
 {
     if (!previousValue.isEmpty() && lastChangeTime.elapsed() > 1000) {
         ratioSet[previousValue] += lastChangeTime.elapsed() / 1000;
     }
 
     lastChangeTime.start();
     previousValue = valueToString(property.read(obj));
 }
 
 QString PropertyRatioSourcePrivate::valueToString(const QVariant &value) const
 {
     const auto it = std::find_if(valueMap.constBegin(), valueMap.constEnd(), [value](QPair<QVariant, QString> p) {
             return p.first == value;
     });
     if (it != valueMap.constEnd()) {
         return it->second;
     }
     return value.toString();
 }
 
 void PropertyRatioSourcePrivate::trySetup()
 {
     if (!obj || propertyName.isEmpty())
         return;
 
     auto idx = obj->metaObject()->indexOfProperty(propertyName.constData());
     Q_ASSERT(idx >= 0);
     if (idx < 0) {
         qCWarning(Log) << "Property" << propertyName << "not found in" << obj << "!";
         return;
     }
 
     property = obj->metaObject()->property(idx);
     if (!property.hasNotifySignal()) {
         qCWarning(Log) << "Property" << propertyName << "has no notification signal!";
         return;
     }
 
     idx = signalMonitor->metaObject()->indexOfMethod("propertyChanged()");
     Q_ASSERT(idx >= 0);
     const auto propertyChangedMethod = signalMonitor->metaObject()->method(idx);
     QObject::connect(obj, property.notifySignal(), signalMonitor, propertyChangedMethod);
 
     lastChangeTime.start();
     propertyChangedMethod.invoke(signalMonitor, Qt::QueuedConnection);
 }
 
 PropertyRatioSource::PropertyRatioSource(QObject *obj, const char *propertyName, const QString &sampleName) :
     AbstractDataSource(sampleName, Provider::DetailedUsageStatistics, new PropertyRatioSourcePrivate)
 {
     Q_D(PropertyRatioSource);
 
     d->obj = obj;
     d->propertyName = propertyName;
     d->signalMonitor = new SignalMonitor(d);
     d->trySetup();
 }
 
 QObject* PropertyRatioSource::object() const
 {
     Q_D(const PropertyRatioSource);
     return d->obj;
 }
 
 void PropertyRatioSource::setObject(QObject* object)
 {
     Q_D(PropertyRatioSource);
     if (d->obj == object)
         return;
     d->obj = object;
     d->trySetup();
 }
 
 QString PropertyRatioSource::propertyName() const
 {
     Q_D(const PropertyRatioSource);
     return QString::fromUtf8(d->propertyName.constData());
 }
 
 void PropertyRatioSource::setPropertyName(const QString& name)
 {
     Q_D(PropertyRatioSource);
     const auto n = name.toUtf8();
     if (d->propertyName == n)
         return;
     d->propertyName = n;
     d->trySetup();
 }
 
 void PropertyRatioSource::addValueMapping(const QVariant &value, const QString &str)
 {
     Q_D(PropertyRatioSource);
     auto it = std::find_if(d->valueMap.begin(), d->valueMap.end(), [value](QPair<QVariant, QString> p) {
             return p.first == value;
     });
     if (it != d->valueMap.end()) {
         it->second = str;
     } else {
         d->valueMap.append(QPair<QVariant, QString>(value, str));
     }
 }
 
 QString PropertyRatioSource::name() const
 {
     Q_D(const PropertyRatioSource);
     return d->name;
 }
 
 void PropertyRatioSource::setName(const QString &name)
 {
     Q_D(PropertyRatioSource);
     d->name = name;
 }
 
 QString PropertyRatioSource::description() const
 {
     Q_D(const PropertyRatioSource);
     return d->description;
 }
 
 void PropertyRatioSource::setDescription(const QString& desc)
 {
     Q_D(PropertyRatioSource);
     d->description = desc;
 }
 
 QVariant PropertyRatioSource::data()
 {
     Q_D(PropertyRatioSource);
     d->propertyChanged();
 
     QVariantMap m;
     int total = 0;
     for (auto it = d->ratioSet.constBegin(); it != d->ratioSet.constEnd(); ++it)
         total += it.value() + d->baseRatioSet.value(it.key());
     if (total <= 0)
         return m;
 
     for (auto it = d->ratioSet.constBegin(); it != d->ratioSet.constEnd(); ++it) {
         double currentValue = it.value() + d->baseRatioSet.value(it.key());
         QVariantMap v;
         v.insert(QStringLiteral("property"), currentValue / (double)(total));
         m.insert(it.key(), v);
     }
 
     return m;
 }
 
 void PropertyRatioSource::loadImpl(QSettings *settings)
 {
     Q_D(PropertyRatioSource);
     foreach (const auto &value, settings->childKeys()) {
         const auto amount = std::max(settings->value(value, 0).toInt(), 0);
         d->baseRatioSet.insert(value, amount);
         if (!d->ratioSet.contains(value))
             d->ratioSet.insert(value, 0);
     }
 }
 
 void PropertyRatioSource::storeImpl(QSettings *settings)
 {
     Q_D(PropertyRatioSource);
     d->propertyChanged();
 
     // note that a second process can have updated the data meanwhile!
     for (auto it = d->ratioSet.begin(); it != d->ratioSet.end(); ++it) {
         if (it.value() == 0)
             continue;
         const auto oldValue = std::max(settings->value(it.key(), 0).toInt(), 0);
         const auto newValue = oldValue + it.value();
         settings->setValue(it.key(), newValue);
         *it = 0;
         d->baseRatioSet.insert(it.key(), newValue);
     }
 }
 
 void PropertyRatioSource::resetImpl(QSettings* settings)
 {
     Q_D(PropertyRatioSource);
     d->baseRatioSet.clear();
     d->ratioSet.clear();
     settings->remove(QString());
 }
 
 #include "propertyratiosource.moc"