File indexing completed on 2024-09-29 04:26:09

 /**
  * 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 "remotecommandsmodel.h"
 #include "interfaces_debug.h"
 
 #include <QDebug>
 
 #include <dbushelper.h>
 
 RemoteCommandsModel::RemoteCommandsModel(QObject *parent)
     : QAbstractListModel(parent)
     , m_dbusInterface(nullptr)
 {
     connect(this, &QAbstractItemModel::rowsInserted, this, &RemoteCommandsModel::rowsChanged);
     connect(this, &QAbstractItemModel::rowsRemoved, this, &RemoteCommandsModel::rowsChanged);
 
     QDBusServiceWatcher *watcher =
         new QDBusServiceWatcher(DaemonDbusInterface::activatedService(), QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForOwnerChange, this);
     connect(watcher, &QDBusServiceWatcher::serviceRegistered, this, &RemoteCommandsModel::refreshCommandList);
     connect(watcher, &QDBusServiceWatcher::serviceUnregistered, this, &RemoteCommandsModel::clearCommands);
 }
 
 QHash<int, QByteArray> RemoteCommandsModel::roleNames() const
 {
     // Role names for QML
     QHash<int, QByteArray> names = QAbstractItemModel::roleNames();
     names.insert(KeyRole, "key");
     names.insert(NameRole, "name");
     names.insert(CommandRole, "command");
     return names;
 }
 
 RemoteCommandsModel::~RemoteCommandsModel()
 {
 }
 
 QString RemoteCommandsModel::deviceId() const
 {
     return m_deviceId;
 }
 
 void RemoteCommandsModel::setDeviceId(const QString &deviceId)
 {
     m_deviceId = deviceId;
 
     if (m_dbusInterface) {
         delete m_dbusInterface;
     }
 
     m_dbusInterface = new RemoteCommandsDbusInterface(deviceId, this);
 
     connect(m_dbusInterface, &OrgKdeKdeconnectDeviceRemotecommandsInterface::commandsChanged, this, &RemoteCommandsModel::refreshCommandList);
 
     refreshCommandList();
 
     Q_EMIT deviceIdChanged(deviceId);
 }
 
 void RemoteCommandsModel::refreshCommandList()
 {
     if (!m_dbusInterface) {
         return;
     }
 
     clearCommands();
 
     if (!m_dbusInterface->isValid()) {
         qCWarning(KDECONNECT_INTERFACES) << "dbus interface not valid";
         return;
     }
 
     const auto cmds = QJsonDocument::fromJson(m_dbusInterface->commands()).object();
 
     beginResetModel();
 
     for (auto it = cmds.constBegin(), itEnd = cmds.constEnd(); it != itEnd; ++it) {
         const QJsonObject cont = it->toObject();
         Command command;
         command.key = it.key();
         command.name = cont.value(QStringLiteral("name")).toString();
         command.command = cont.value(QStringLiteral("command")).toString();
         m_commandList.append(command);
     }
 
     endResetModel();
 }
 
 QVariant RemoteCommandsModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.row() < 0 || index.row() >= m_commandList.count()) {
         return QVariant();
     }
 
     if (!m_dbusInterface || !m_dbusInterface->isValid()) {
         return QVariant();
     }
 
     Command command = m_commandList[index.row()];
 
     switch (role) {
     case KeyRole:
         return command.key;
     case NameRole:
         return command.name;
     case CommandRole:
         return command.command;
     default:
         return QVariant();
     }
 }
 
 int RemoteCommandsModel::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_commandList.count();
 }
 
 void RemoteCommandsModel::clearCommands()
 {
     if (!m_commandList.isEmpty()) {
         beginRemoveRows(QModelIndex(), 0, m_commandList.size() - 1);
         m_commandList.clear();
         endRemoveRows();
     }
 }
 
 #include "moc_remotecommandsmodel.cpp"