• Skip to content
  • Skip to link menu
KDE 4.2 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

libsolidcontrol

networkmanager.cpp

Go to the documentation of this file.
00001 /*  This file is part of the KDE project
00002     Copyright (C) 2006 Will Stephenson <wstephenson@kde.org>
00003     Copyright (C) 2006-2007 Kevin Ottens <ervin@kde.org>
00004 
00005     This library is free software; you can redistribute it and/or
00006     modify it under the terms of the GNU Library General Public
00007     License version 2 as published by the Free Software Foundation.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public License
00015     along with this library; see the file COPYING.LIB.  If not, write to
00016     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017     Boston, MA 02110-1301, USA.
00018 
00019 */
00020 
00021 #include "ifaces/networkmanager.h"
00022 #include "ifaces/networkinterface.h"
00023 #include "ifaces/wirednetworkinterface.h"
00024 #include "ifaces/wirelessnetworkinterface.h"
00025 #include "ifaces/networkgsminterface.h"
00026 #include "ifaces/networkcdmainterface.h"
00027 
00028 #include "soliddefs_p.h"
00029 #include "networkmanager_p.h"
00030 #include "networkinterface.h"
00031 #include "wirednetworkinterface.h"
00032 #include "wirelessnetworkinterface.h"
00033 
00034 #include "networkmanager.h"
00035 
00036 #include <kglobal.h>
00037 
00038 #include <kdebug.h>
00039 
00040 K_GLOBAL_STATIC(Solid::Control::NetworkManagerPrivate, globalNetworkManager)
00041 
00042 Solid::Control::NetworkManagerPrivate::NetworkManagerPrivate() : m_invalidDevice(0)
00043 {
00044     loadBackend("Network Management",
00045                 "SolidNetworkManager",
00046                 "Solid::Control::Ifaces::NetworkManager");
00047 
00048     if (managerBackend()!=0) {
00049         connect(managerBackend(), SIGNAL(networkInterfaceAdded(const QString &)),
00050                 this, SLOT(_k_networkInterfaceAdded(const QString &)));
00051         connect(managerBackend(), SIGNAL(networkInterfaceRemoved(const QString &)),
00052                 this, SLOT(_k_networkInterfaceRemoved(const QString &)));
00053         connect(managerBackend(), SIGNAL(statusChanged(Solid::Networking::Status)),
00054                 this, SIGNAL(statusChanged(Solid::Networking::Status)));
00055         connect(managerBackend(), SIGNAL(wirelessEnabledChanged(bool)),
00056                 this, SIGNAL(wirelessEnabledChanged(bool)));
00057         connect(managerBackend(), SIGNAL(wirelessHardwareEnabledChanged(bool)),
00058                 this, SIGNAL(wirelessHardwareEnabledChanged(bool)));
00059         connect(managerBackend(), SIGNAL(activeConnectionsChanged()),
00060                 this, SIGNAL(activeConnectionsChanged()));
00061     }
00062 }
00063 
00064 Solid::Control::NetworkManagerPrivate::~NetworkManagerPrivate()
00065 {
00066     // Delete all the devices, they are now outdated
00067     typedef QPair<NetworkInterface *, QObject *> NetworkInterfaceIfacePair;
00068 
00069     foreach (const NetworkInterfaceIfacePair &pair, m_networkInterfaceMap) {
00070         delete pair.first;
00071         delete pair.second;
00072     }
00073 
00074     m_networkInterfaceMap.clear();
00075 }
00076 
00077 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManagerPrivate::buildDeviceList(const QStringList &uniList)
00078 {
00079     NetworkInterfaceList list;
00080     Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00081 
00082     if (backend == 0) return list;
00083 
00084     foreach (const QString &uni, uniList)
00085     {
00086         QPair<NetworkInterface *, QObject *> pair = findRegisteredNetworkInterface(uni);
00087 
00088         if (pair.first!= 0)
00089         {
00090             list.append(pair.first);
00091         }
00092     }
00093 
00094     return list;
00095 }
00096 
00097 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManagerPrivate::networkInterfaces()
00098 {
00099     Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00100 
00101     if (backend!= 0)
00102     {
00103         return buildDeviceList(backend->networkInterfaces());
00104     }
00105     else
00106     {
00107         return NetworkInterfaceList();
00108     }
00109 }
00110 
00111 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManager::networkInterfaces()
00112 {
00113     return globalNetworkManager->networkInterfaces();
00114 }
00115 
00116 bool Solid::Control::NetworkManager::isNetworkingEnabled()
00117 {
00118     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isNetworkingEnabled());
00119 }
00120 
00121 bool Solid::Control::NetworkManager::isWirelessEnabled()
00122 {
00123     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isWirelessEnabled());
00124 }
00125 
00126 bool Solid::Control::NetworkManager::isWirelessHardwareEnabled()
00127 {
00128     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isWirelessHardwareEnabled());
00129 }
00130 
00131 void Solid::Control::NetworkManager::setNetworkingEnabled(bool enabled)
00132 {
00133     SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), setNetworkingEnabled(enabled));
00134 }
00135 
00136 void Solid::Control::NetworkManager::setWirelessEnabled(bool enabled)
00137 {
00138     SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), setWirelessEnabled(enabled));
00139 }
00140 
00141 Solid::Networking::Status Solid::Control::NetworkManager::status()
00142 {
00143     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), Solid::Networking::Unknown, status());
00144 }
00145 
00146 Solid::Control::NetworkInterface * Solid::Control::NetworkManagerPrivate::findNetworkInterface(const QString &uni)
00147 {
00148     Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00149 
00150     if (backend == 0) return 0;
00151 
00152     QPair<NetworkInterface *, QObject *> pair = findRegisteredNetworkInterface(uni);
00153 
00154     if (pair.first != 0)
00155     {
00156         return pair.first;
00157     }
00158     else
00159     {
00160         return 0;
00161     }
00162 }
00163 
00164 Solid::Control::NetworkInterface * Solid::Control::NetworkManager::findNetworkInterface(const QString &uni)
00165 {
00166     return globalNetworkManager->findNetworkInterface(uni);
00167 }
00168 
00169 Solid::Control::NetworkManager::Notifier * Solid::Control::NetworkManager::notifier()
00170 {
00171     return globalNetworkManager;
00172 }
00173 
00174 void Solid::Control::NetworkManagerPrivate::_k_networkInterfaceAdded(const QString &uni)
00175 {
00176     QPair<NetworkInterface *, QObject*> pair = m_networkInterfaceMap.take(uni);
00177 
00178     if (pair.first!= 0)
00179     {
00180         // Oops, I'm not sure it should happen...
00181         // But well in this case we'd better kill the old device we got, it's probably outdated
00182 
00183         delete pair.first;
00184         delete pair.second;
00185     }
00186 
00187     emit networkInterfaceAdded(uni);
00188 }
00189 
00190 void Solid::Control::NetworkManagerPrivate::_k_networkInterfaceRemoved(const QString &uni)
00191 {
00192     QPair<NetworkInterface *, QObject *> pair = m_networkInterfaceMap.take(uni);
00193 
00194     if (pair.first!= 0)
00195     {
00196         delete pair.first;
00197         delete pair.second;
00198     }
00199 
00200     emit networkInterfaceRemoved(uni);
00201 }
00202 
00203 void Solid::Control::NetworkManagerPrivate::_k_destroyed(QObject *object)
00204 {
00205     Ifaces::NetworkInterface *device = qobject_cast<Ifaces::NetworkInterface *>(object);
00206 
00207     if (device!=0)
00208     {
00209         QString uni = device->uni();
00210         QPair<NetworkInterface *, QObject *> pair = m_networkInterfaceMap.take(uni);
00211         delete pair.first;
00212     }
00213 }
00214 
00215 /***************************************************************************/
00216 
00217 QPair<Solid::Control::NetworkInterface *, QObject *>
00218 Solid::Control::NetworkManagerPrivate::findRegisteredNetworkInterface(const QString &uni)
00219 {
00220     if (m_networkInterfaceMap.contains(uni)) {
00221         return m_networkInterfaceMap[uni];
00222     } else {
00223         Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00224 
00225         if (backend!=0)
00226         {
00227             QObject * iface = backend->createNetworkInterface(uni);
00228             NetworkInterface *device = 0;
00229             if (qobject_cast<Ifaces::WirelessNetworkInterface *>(iface) != 0) {
00230                 device = new WirelessNetworkInterface(iface);
00231             } else if (qobject_cast<Ifaces::WiredNetworkInterface *>(iface) != 0) {
00232                 device = new WiredNetworkInterface(iface);
00233             } else if (qobject_cast<Ifaces::GsmNetworkInterface *>(iface) != 0) {
00234                 device = new GsmNetworkInterface(iface);
00235             } else if (qobject_cast<Ifaces::CdmaNetworkInterface *>(iface) != 0) {
00236                 device = new CdmaNetworkInterface(iface);
00237             } else {
00238                 kDebug() << "Unhandled network interface: " << uni;
00239             }
00240             if (device != 0) {
00241                 QPair<NetworkInterface *, QObject *> pair(device, iface);
00242                 connect(iface, SIGNAL(destroyed(QObject *)),
00243                         this, SLOT(_k_destroyed(QObject *)));
00244                 m_networkInterfaceMap[uni] = pair;
00245                 return pair;
00246             }
00247             else
00248             {
00249                 return QPair<NetworkInterface *, QObject *>(0, 0);
00250             }
00251         }
00252         else
00253         {
00254             return QPair<NetworkInterface *, QObject *>(0, 0);
00255         }
00256     }
00257 }
00258 
00259 void Solid::Control::NetworkManager::activateConnection(const QString & interfaceUni, const QString & connectionUni,
00260                 const QVariantMap & connectionParameters )
00261 {
00262     SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), activateConnection(interfaceUni, connectionUni, connectionParameters));
00263 }
00264 
00265 void Solid::Control::NetworkManager::deactivateConnection(const QString & activeConnectionUni)
00266 {
00267     SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), deactivateConnection(activeConnectionUni));
00268 }
00269 
00270 QStringList Solid::Control::NetworkManager::activeConnections()
00271 {
00272     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), QStringList(), activeConnections());
00273 }
00274 
00275 #include "networkmanager_p.moc"
00276 #include "networkmanager.moc"

libsolidcontrol

Skip menu "libsolidcontrol"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

API Reference

Skip menu "API Reference"
  • KWin
  •   KWin Libraries
  • Libraries
  •   libkworkspace
  •   libsolidcontrol
  •   libtaskmanager
  • Plasma
  •   Animators
  •   Applets
  •   Engines
  • Solid Modules
Generated for API Reference by doxygen 1.5.7
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal