File indexing completed on 2023-09-24 08:52:41

 /**
  * SPDX-FileCopyrightText: 2018 Nicolas Fella <nicolas.fella@gmx.de>
  *
  * SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
  */
 
 #include "remotesinksmodel.h"
 #include "interfaces_debug.h"
 
 #include <QDebug>
 
 #include <core/qtcompat_p.h>
 #include <dbushelper.h>
 
 RemoteSinksModel::RemoteSinksModel(QObject *parent)
     : QAbstractListModel(parent)
     , m_dbusInterface(nullptr)
 {
     connect(this, &QAbstractItemModel::rowsInserted, this, &RemoteSinksModel::rowsChanged);
     connect(this, &QAbstractItemModel::rowsRemoved, this, &RemoteSinksModel::rowsChanged);
 
     QDBusServiceWatcher *watcher =
         new QDBusServiceWatcher(DaemonDbusInterface::activatedService(), QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForOwnerChange, this);
     connect(watcher, &QDBusServiceWatcher::serviceRegistered, this, &RemoteSinksModel::refreshSinkList);
     connect(watcher, &QDBusServiceWatcher::serviceUnregistered, this, &RemoteSinksModel::refreshSinkList);
 }
 
 QHash<int, QByteArray> RemoteSinksModel::roleNames() const
 {
     // Role names for QML
     QHash<int, QByteArray> names = QAbstractItemModel::roleNames();
     names.insert(NameRole, "name");
     names.insert(DescriptionRole, "description");
     names.insert(MaxVolumeRole, "maxVolume");
     names.insert(VolumeRole, "volume");
     names.insert(MutedRole, "muted");
 
     return names;
 }
 
 RemoteSinksModel::~RemoteSinksModel()
 {
 }
 
 QString RemoteSinksModel::deviceId() const
 {
     return m_deviceId;
 }
 
 void RemoteSinksModel::setDeviceId(const QString &deviceId)
 {
     m_deviceId = deviceId;
 
     if (m_dbusInterface) {
         delete m_dbusInterface;
     }
 
     m_dbusInterface = new RemoteSystemVolumeDbusInterface(deviceId, this);
 
     connect(m_dbusInterface, &OrgKdeKdeconnectDeviceRemotesystemvolumeInterface::sinksChanged, this, &RemoteSinksModel::refreshSinkList);
 
     connect(m_dbusInterface, &OrgKdeKdeconnectDeviceRemotesystemvolumeInterface::volumeChanged, this, [this](const QString &name, int volume) {
         auto iter = std::find_if(m_sinkList.begin(), m_sinkList.end(), [&name](const Sink &s) {
             return s.name == name;
         });
         if (iter != m_sinkList.end()) {
             iter->volume = volume;
             int i = std::distance(m_sinkList.begin(), iter);
             Q_EMIT dataChanged(index(i, 0), index(i, 0), {VolumeRole});
         }
     });
 
     connect(m_dbusInterface, &OrgKdeKdeconnectDeviceRemotesystemvolumeInterface::mutedChanged, this, [this](const QString &name, bool muted) {
         auto iter = std::find_if(m_sinkList.begin(), m_sinkList.end(), [&name](const Sink &s) {
             return s.name == name;
         });
         if (iter != m_sinkList.cend()) {
             iter->muted = muted;
             int i = std::distance(m_sinkList.begin(), iter);
             Q_EMIT dataChanged(index(i, 0), index(i, 0), {MutedRole});
         }
     });
 
     refreshSinkList();
 
     Q_EMIT deviceIdChanged(deviceId);
 }
 
 void RemoteSinksModel::refreshSinkList()
 {
     if (!m_dbusInterface) {
         return;
     }
 
     if (!m_dbusInterface->isValid()) {
         qCWarning(KDECONNECT_INTERFACES) << "dbus interface not valid";
         return;
     }
 
     beginResetModel();
     m_sinkList.clear();
 
     const auto cmds = QJsonDocument::fromJson(m_dbusInterface->sinks()).array();
     for (const QJsonValue &cmd : cmds) {
         const QJsonObject cont = cmd.toObject();
         Sink sink;
         sink.name = cont.value(QStringLiteral("name")).toString();
         sink.description = cont.value(QStringLiteral("description")).toString();
         sink.maxVolume = cont.value(QStringLiteral("maxVolume")).toInt();
         sink.volume = cont.value(QStringLiteral("volume")).toInt();
         sink.muted = cont.value(QStringLiteral("muted")).toBool();
         m_sinkList.append(sink);
     }
 
     endResetModel();
 }
 
 QVariant RemoteSinksModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.row() < 0 || index.row() >= m_sinkList.count()) {
         return QVariant();
     }
 
     if (!m_dbusInterface || !m_dbusInterface->isValid()) {
         return QVariant();
     }
 
     const Sink &sink = m_sinkList[index.row()];
 
     switch (role) {
     case NameRole:
         return sink.name;
     case DescriptionRole:
         return sink.description;
     case MaxVolumeRole:
         return sink.maxVolume;
     case VolumeRole:
         return sink.volume;
     case MutedRole:
         return sink.muted;
     default:
         return QVariant();
     }
 }
 
 bool RemoteSinksModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid() || index.row() < 0 || index.row() >= m_sinkList.count()) {
         return false;
     }
 
     if (!m_dbusInterface || !m_dbusInterface->isValid()) {
         return false;
     }
 
     const QString sinkName = m_sinkList[index.row()].name;
     switch (role) {
     case VolumeRole:
         m_dbusInterface->sendVolume(sinkName, value.toInt());
         return true;
     case MutedRole:
         m_dbusInterface->sendMuted(sinkName, value.toBool());
         return true;
     default:
         return false;
     }
 }
 
 int RemoteSinksModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         // Return size 0 if we are a child because this is not a tree
         return 0;
     }
 
     return m_sinkList.count();
 }