File indexing completed on 2024-04-28 07:49:03

 /*
     SPDX-FileCopyrightText: 2014 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "device.h"
 #include "activeconnection.h"
 
 #include <QDBusConnection>
 #include <QDBusMetaType>
 
 Device::Device(QObject *parent)
     : QObject(parent)
     , m_activeConnection(QDBusObjectPath("/"))
     , m_autoconnect(true)
     , m_capabilities(0)
     , m_deviceType(0)
     , m_dhcp4Config(QDBusObjectPath("/"))
     , m_dhcp6Config(QDBusObjectPath("/"))
     , m_firmwareMissing(false)
     , m_interfaceFlags(NM_DEVICE_INTERFACE_FLAG_NONE)
     , m_ip4Address(0)
     , m_ip4Config(QDBusObjectPath("/"))
     , m_ip6Config(QDBusObjectPath("/"))
     , m_managed(true)
     , m_mtu(0)
     , m_state(30)
 {
     qDBusRegisterMetaType<DeviceDBusStateReason>();
 }
 
 Device::~Device()
 {
 }
 
 QDBusObjectPath Device::activeConnection() const
 {
     return m_activeConnection;
 }
 
 bool Device::autoconnect() const
 {
     return m_autoconnect;
 }
 
 void Device::setAutoconnect(bool autoconnect)
 {
     m_autoconnect = autoconnect;
 }
 
 QList<QDBusObjectPath> Device::availableConnections() const
 {
     return m_availableConnections;
 }
 
 uint Device::capabilities() const
 {
     return m_capabilities;
 }
 
 QString Device::deviceInterface() const
 {
     if (m_deviceType == NetworkManager::Device::Ethernet) {
         return QLatin1String("org.kde.fakenetwork.Device.Wired");
     } else if (m_deviceType == NetworkManager::Device::Wifi) {
         return QLatin1String("org.kde.fakenetwork.Device.Wireless");
     }
 
     return QLatin1String("org.kde.fakenetwork.Device.Wired");
 }
 
 QString Device::devicePath() const
 {
     return m_devicePath;
 }
 
 void Device::setDevicePath(const QString &devicePath)
 {
     m_devicePath = devicePath;
 }
 
 uint Device::deviceType() const
 {
     return m_deviceType;
 }
 
 QDBusObjectPath Device::dhcp4Config() const
 {
     return m_dhcp4Config;
 }
 
 QDBusObjectPath Device::dhcp6Config() const
 {
     return m_dhcp6Config;
 }
 
 QString Device::driver() const
 {
     return m_driver;
 }
 
 QString Device::driverVersion() const
 {
     return m_driverVersion;
 }
 
 bool Device::firmwareMissing() const
 {
     return m_firmwareMissing;
 }
 
 QString Device::firmwareVersion() const
 {
     return m_firmwareVersion;
 }
 
 QString Device::interface() const
 {
     return m_interface;
 }
 
 int Device::ip4Address() const
 {
     return m_ip4Address;
 }
 
 QDBusObjectPath Device::ip4Config() const
 {
     return m_ip4Config;
 }
 
 QDBusObjectPath Device::ip6Config() const
 {
     return m_ip6Config;
 }
 
 QString Device::ipInterface() const
 {
     return m_ipInterface;
 }
 
 uint Device::interfaceFlags() const
 {
     return m_interfaceFlags;
 }
 
 bool Device::managed() const
 {
     return m_managed;
 }
 
 uint Device::mtu() const
 {
     return m_mtu;
 }
 
 uint Device::state() const
 {
     return m_state;
 }
 
 DeviceDBusStateReason Device::stateReason() const
 {
     return m_stateReason;
 }
 
 QString Device::udi() const
 {
     return m_udi;
 }
 
 void Device::addAvailableConnection(const QDBusObjectPath &availableConnection)
 {
     m_availableConnections << availableConnection;
 }
 
 void Device::removeAvailableConnection(const QDBusObjectPath &availableConnection)
 {
     m_availableConnections.removeAll(availableConnection);
 }
 
 void Device::setActiveConnection(const QString &activeConnection)
 {
     m_activeConnection = QDBusObjectPath(activeConnection);
 }
 
 void Device::setCapabilities(uint capabilities)
 {
     m_capabilities = capabilities;
 }
 
 void Device::setDeviceType(uint deviceType)
 {
     m_deviceType = deviceType;
 }
 
 void Device::setDhcp4Config(const QString &config)
 {
     m_dhcp4Config = QDBusObjectPath(config);
 }
 
 void Device::setDhcp6Config(const QString &config)
 {
     m_dhcp6Config = QDBusObjectPath(config);
 }
 
 void Device::setDriver(const QString &driver)
 {
     m_driver = driver;
 }
 
 void Device::setDriverVersion(const QString &driverVersion)
 {
     m_driverVersion = driverVersion;
 }
 
 void Device::setFirmwareMissing(bool firmwareMissing)
 {
     m_firmwareMissing = firmwareMissing;
 }
 
 void Device::setFirmwareVersion(const QString &firmwareVersion)
 {
     m_firmwareVersion = firmwareVersion;
 }
 
 void Device::setInterface(const QString &interface)
 {
     m_interface = interface;
 }
 
 void Device::setInterfaceFlags(uint interfaceFlags)
 {
     m_interfaceFlags = interfaceFlags;
 }
 
 void Device::setIp4Config(const QString &config)
 {
     m_ip4Config = QDBusObjectPath(config);
 }
 
 void Device::setIp6Config(const QString &config)
 {
     m_ip6Config = QDBusObjectPath(config);
 }
 
 void Device::setIpv4Address(int address)
 {
     m_ip4Address = address;
 }
 
 void Device::setIpInterface(const QString &interface)
 {
     m_ipInterface = interface;
 }
 
 void Device::setManaged(bool managed)
 {
     m_managed = managed;
 }
 
 void Device::setMtu(uint mtu)
 {
     m_mtu = mtu;
 }
 
 void Device::setState(uint state)
 {
     uint previousState = m_state;
     m_state = state;
     m_stateReason.state = state;
 
     QDBusMessage message = QDBusMessage::createSignal(m_devicePath, QLatin1String("org.kde.fakenetwork.Device"), QLatin1String("StateChanged"));
     message << previousState << state << m_stateReason.reason;
     QDBusConnection::sessionBus().send(message);
 }
 
 void Device::setStateReason(const DeviceDBusStateReason &reason)
 {
     m_stateReason = reason;
 }
 
 void Device::setUdi(const QString &udi)
 {
     m_udi = udi;
 }
 
 void Device::Disconnect()
 {
     // TODO
 }
 
 #include "moc_device.cpp"