fakenetwork/device.cpp

/*
    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"