workspace/libs/solid/control/networkinterface.h

   1 /*  This file is part of the KDE project
   2     Copyright (C) 2006 Will Stephenson <wstephenson@kde.org>
   3     Copyright (C) 2007 Kevin Ottens <ervin@kde.org>
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License version 2 as published by the Free Software Foundation.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Library General Public License for more details.
  13
  14     You should have received a copy of the GNU Library General Public License
  15     along with this library; see the file COPYING.LIB.  If not, write to
  16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17     Boston, MA 02110-1301, USA.
  18
  19 */
  20
  21 #ifndef SOLID_CONTROL_NETWORKINTERFACE_H
  22 #define SOLID_CONTROL_NETWORKINTERFACE_H
  23
  24 #include <QtCore/QObject>
  25 #include <QtCore/QStringList>
  26 #include <QtNetwork/QNetworkAddressEntry>
  27
  28 #include "solid_control_export.h"
  29
  30 #include "networkipv4config.h"
  31
  32 namespace Solid
  33 {
  34 namespace Control
  35 {
  36     class NetworkInterfacePrivate;
  37
  38     /**
  39      * This interface represents a generic network interface in the system
  40      */
  41     class SOLIDCONTROL_EXPORT NetworkInterface : public QObject
  42     {
  43     Q_OBJECT
  44     Q_ENUMS(ConnectionState Capability Type)
  45     Q_FLAGS(Capabilities)
  46     Q_DECLARE_PRIVATE(NetworkInterface)
  47
  48     public:
  49         // == NM ActivationStage
  50         /**
  51          * Device connection states describe the possible states of a
  52          * network connection from the user's point of view.  For
  53          * simplicity, states from several different layers are present -
  54          * this is a high level view
  55          */
  56         enum ConnectionState{ UnknownState, Unmanaged, Unavailable, Disconnected, Preparing,
  57                               Configuring, NeedAuth, IPConfig, Activated, Failed };
  58         /**
  59          * Possible Device capabilities
  60          * - IsManageable: denotes that the device can be controlled by this API
  61          * - SupportsCarrierDetect: the device informs us when it is plugged in to the medium
  62          * - SupportsWirelessScan: the device can scan for wireless networks
  63          */
  64         enum Capability { IsManageable = 0x1, SupportsCarrierDetect = 0x2 };
  65         /**
  66          * Device medium types
  67          * - Ieee8023: wired ethernet
  68          * - Ieee80211: the popular family of wireless networks
  69          * - Gsm: cellular device of the GSM family, used in Europe
  70          * - Cdma: cellular device of the CDMA family, used in the USA
  71          */
  72         enum Type { UnknownType, Ieee8023, Ieee80211, Serial, Gsm, Cdma };
  73
  74         Q_DECLARE_FLAGS(Capabilities, Capability)
  75
  76         /**
  77          * Creates a new NetworkInterface object.
  78          *
  79          * @param backendObject the network object provided by the backend
  80          */
  81         explicit NetworkInterface(QObject *backendObject);
  82
  83         /**
  84          * Constructs a copy of a network.
  85          *
  86          * @param network the network to copy
  87          */
  88         NetworkInterface(const NetworkInterface &network);
  89
  90         /**
  91          * Destroys a NetworkInterface object.
  92          */
  93         virtual ~NetworkInterface();
  94
  95         /**
  96          * Retrieves the interface type.  This is a virtual function that will return the
  97          * proper type of all sub-classes.
  98          *
  99          * @returns the NetworkInterface::Type that corresponds to this device.
 100          */
 101         virtual Type type() const;
 102
 103         /**
 104          * Retrieves the Unique Network Identifier (UNI) of the NetworkInterface.
 105          * This identifier is unique for each network and network interface in the system.
 106          *
 107          * @returns the Unique Network Identifier of the current network
 108          */
 109         QString uni() const;
 110
 111         /**
 112          * The system name for the network interface
 113          */
 114         QString interfaceName() const;
 115
 116         /**
 117          * Handle for the system driver controlling this network interface
 118          */
 119         QString driver() const;
 120
 121         Solid::Control::IPv4Config ipV4Config() const;
 122         /**
 123          * Retrieves the activation status of this network interface.
 124          *
 125          * @return true if this network interface is active, false otherwise
 126          */
 127         bool isActive() const;
 128
 129         /**
 130          * Retrieves the current state of the network connection held by this device.
 131          * It's a high level view of the connection. It is user oriented, so
 132          * actually it provides state coming from different layers.
 133          *
 134          * @return the current connection state
 135          * @see Solid::Control::NetworkInterface::ConnectionState
 136          */
 137         ConnectionState connectionState() const;
 138
 139         /**
 140          * Retrieves the maximum speed as reported by the device.
 141          * Note that this is only a design related piece of information, and that
 142          * the device might not reach this maximum.
 143          *
 144          * @return the device's maximum speed
 145          */
 146         int designSpeed() const;
 147
 148         /**
 149          * Retrieves the capabilities supported by this device.
 150          *
 151          * @return the capabilities of the device
 152          */
 153         Capabilities capabilities() const;
 154
 155     Q_SIGNALS:
 156         /**
 157          * This signal is emitted when the settings of this network have changed.
 158          */
 159         void ipDetailsChanged();
 160
 161         /**
 162          * This signal is emitted when the device's link status changed. For example, if there
 163          * is no carrier anymore.
 164          *
 165          * @param linkActivated true if the carrier got detected, false otherwise
 166          */
 167         void linkUpChanged(bool linkActivated);
 168
 169         /**
 170          * This signal is emitted when the device's link status changed. For example, if there
 171          * is no carrier anymore.
 172          *
 173          * @param state the new state of the connection
 174          * @see Solid::Control::NetworkInterface::ConnectionState
 175          */
 176         void connectionStateChanged(int state);
 177
 178     protected:
 179         /**
 180          * @internal
 181          */
 182         NetworkInterface(NetworkInterfacePrivate &dd, QObject *backendObject);
 183
 184         /**
 185          * @internal
 186          */
 187         NetworkInterface(NetworkInterfacePrivate &dd, const NetworkInterface &network);
 188
 189         NetworkInterfacePrivate *d_ptr;
 190
 191     private:
 192     //HACK: to make NetworkList polymorphic (containing both wired and wireless networks, I used Network * here - Will.
 193     };
 194     typedef QList<NetworkInterface *> NetworkInterfaceList;
 195
 196
 197 } //Control
 198 } //Solid
 199
 200 Q_DECLARE_OPERATORS_FOR_FLAGS(Solid::Control::NetworkInterface::Capabilities)
 201
 202 #endif //SOLID_CONTROL_NETWORKINTERFACE_H
 203