workspace/libs/solid/control/networkinterface.cpp

   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 #include <QMap>
  22 #include <QStringList>
  23
  24 #include <solid/control/ifaces/network.h>
  25 #include <solid/control/ifaces/networkinterface.h>
  26 #include <solid/control/ifaces/wirelessnetwork.h>
  27
  28 #include "frontendobject_p.h"
  29
  30 #include "soliddefs_p.h"
  31 #include "networkmanager.h"
  32 #include "network.h"
  33 #include "network_p.h"
  34 #include "networkinterface.h"
  35 #include "wirelessnetwork.h"
  36
  37 namespace Solid
  38 {
  39 namespace Control
  40 {
  41     class NetworkInterfacePrivate : public FrontendObjectPrivate
  42     {
  43     public:
  44         NetworkInterfacePrivate(QObject *parent)
  45             : FrontendObjectPrivate(parent) { }
  46
  47         void setBackendObject(QObject *object);
  48         void _k_destroyed(QObject *object);
  49
  50         Solid::Control::Network *findRegisteredNetwork(const QString &uni) const;
  51
  52
  53         mutable QMap<QString, Network *> networkMap;
  54         mutable Network invalidNetwork;
  55     };
  56 }
  57 }
  58
  59
  60 Solid::Control::NetworkInterface::NetworkInterface()
  61     : QObject(), d(new NetworkInterfacePrivate(this))
  62 {
  63 }
  64
  65 Solid::Control::NetworkInterface::NetworkInterface(const QString &uni)
  66     : QObject(), d(new NetworkInterfacePrivate(this))
  67 {
  68     const NetworkInterface &device = NetworkManager::findNetworkInterface(uni);
  69     d->setBackendObject(device.d->backendObject());
  70 }
  71
  72 Solid::Control::NetworkInterface::NetworkInterface(QObject *backendObject)
  73     : QObject(), d(new NetworkInterfacePrivate(this))
  74 {
  75     d->setBackendObject(backendObject);
  76 }
  77
  78 Solid::Control::NetworkInterface::NetworkInterface(const NetworkInterface &device)
  79     : QObject(), d(new NetworkInterfacePrivate(this))
  80 {
  81     d->setBackendObject(device.d->backendObject());
  82 }
  83
  84 Solid::Control::NetworkInterface::~NetworkInterface()
  85 {
  86     foreach (QObject *network, d->networkMap)
  87     {
  88         delete network;
  89     }
  90 }
  91
  92 Solid::Control::NetworkInterface &Solid::Control::NetworkInterface::operator=(const Solid::Control::NetworkInterface  & dev)
  93 {
  94     d->setBackendObject(dev.d->backendObject());
  95     return *this;
  96 }
  97
  98 bool Solid::Control::NetworkInterface::isValid() const
  99 {
 100     return d->backendObject()!=0;
 101 }
 102
 103 QString Solid::Control::NetworkInterface::uni() const
 104 {
 105     return_SOLID_CALL(Ifaces::NetworkInterface *, d->backendObject(), QString(), uni());
 106 }
 107
 108 bool Solid::Control::NetworkInterface::isActive() const
 109 {
 110     return_SOLID_CALL(Ifaces::NetworkInterface *, d->backendObject(), false, isActive());
 111 }
 112
 113 Solid::Control::NetworkInterface::Type Solid::Control::NetworkInterface::type() const
 114 {
 115     return_SOLID_CALL(Ifaces::NetworkInterface *, d->backendObject(), UnknownType, type());
 116 }
 117 Solid::Control::NetworkInterface::ConnectionState Solid::Control::NetworkInterface::connectionState() const
 118 {
 119     return_SOLID_CALL(Ifaces::NetworkInterface *, d->backendObject(), UnknownState, connectionState());
 120 }
 121
 122 int Solid::Control::NetworkInterface::signalStrength() const
 123 {
 124     return_SOLID_CALL(Ifaces::NetworkInterface *, d->backendObject(), 0, signalStrength());
 125 }
 126
 127 int Solid::Control::NetworkInterface::designSpeed() const
 128 {
 129     return_SOLID_CALL(Ifaces::NetworkInterface *, d->backendObject(), 0, designSpeed());
 130 }
 131
 132 bool Solid::Control::NetworkInterface::isLinkUp() const
 133 {
 134     return_SOLID_CALL(Ifaces::NetworkInterface *, d->backendObject(), false, isLinkUp());
 135 }
 136
 137 Solid::Control::NetworkInterface::Capabilities Solid::Control::NetworkInterface::capabilities() const
 138 {
 139     return_SOLID_CALL(Ifaces::NetworkInterface *, d->backendObject(), Capabilities(), capabilities());
 140 }
 141
 142 Solid::Control::Network * Solid::Control::NetworkInterface::findNetwork(const QString  & uni) const
 143 {
 144     if (!isValid()) return 0;
 145
 146     Network *network = d->findRegisteredNetwork(uni);
 147
 148     if (network!=0)
 149     {
 150         return network;
 151     }
 152     else
 153     {
 154         return &(d->invalidNetwork);
 155     }
 156 }
 157
 158 Solid::Control::NetworkList Solid::Control::NetworkInterface::networks() const
 159 {
 160     NetworkList list;
 161     Ifaces::NetworkInterface *device = qobject_cast<Ifaces::NetworkInterface *>(d->backendObject());
 162
 163     if (device==0) return list;
 164
 165     QStringList uniList = device->networks();
 166
 167     foreach (const QString &uni, uniList)
 168     {
 169         Network *network = d->findRegisteredNetwork(uni);
 170         if (network!=0)
 171         {
 172             list.append(network);
 173         }
 174     }
 175
 176     return list;
 177 }
 178
 179 void Solid::Control::NetworkInterfacePrivate::_k_destroyed(QObject *object)
 180 {
 181     if (object == backendObject())
 182     {
 183         FrontendObjectPrivate::_k_destroyed(object);
 184
 185         foreach (Network *network, networkMap)
 186         {
 187             delete network->d_func()->backendObject();
 188             delete network;
 189         }
 190
 191         networkMap.clear();
 192     }
 193 }
 194
 195 void Solid::Control::NetworkInterfacePrivate::setBackendObject(QObject *object)
 196 {
 197     foreach (QObject *network, networkMap) {
 198         delete network;
 199     }
 200
 201     networkMap.clear();
 202
 203
 204     FrontendObjectPrivate::setBackendObject(object);
 205
 206     if (object) {
 207         QObject::connect(object, SIGNAL(activeChanged(bool)),
 208                          parent(), SIGNAL(activeChanged(bool)));
 209         QObject::connect(object, SIGNAL(linkUpChanged(bool)),
 210                          parent(), SIGNAL(linkUpChanged(bool)));
 211         QObject::connect(object, SIGNAL(signalStrengthChanged(int)),
 212                          parent(), SIGNAL(signalStrengthChanged(int)));
 213         QObject::connect(object, SIGNAL(connectionStateChanged(int)),
 214                          parent(), SIGNAL(connectionStateChanged(int)));
 215         QObject::connect(object, SIGNAL(networkAppeared(const QString &)),
 216                          parent(), SIGNAL(networkAppeared(const QString &)));
 217         QObject::connect(object, SIGNAL(networkDisappeared(const QString &)),
 218                          parent(), SIGNAL(networkDisappeared(const QString &)));
 219     }
 220 }
 221
 222 Solid::Control::Network *Solid::Control::NetworkInterfacePrivate::findRegisteredNetwork(const QString &uni) const
 223 {
 224     Network *network = 0;
 225
 226     if (networkMap.contains(uni)) {
 227         network = networkMap[uni];
 228     } else {
 229         Ifaces::NetworkInterface *device = qobject_cast<Ifaces::NetworkInterface *>(backendObject());
 230
 231         if (device!=0)
 232         {
 233             QObject *iface = device->createNetwork(uni);
 234
 235             if (qobject_cast<Ifaces::WirelessNetwork *>(iface)!=0)
 236             {
 237                 network = new WirelessNetwork(iface);
 238             }
 239             else if (qobject_cast<Ifaces::Network *>(iface)!=0)
 240             {
 241                 network = new Network(iface);
 242             }
 243
 244             if (network != 0)
 245             {
 246                 networkMap[uni] = network;
 247             }
 248         }
 249     }
 250
 251     return network;
 252 }
 253
 254 #include "networkinterface.moc"