00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "ifaces/networkmanager.h"
00022 #include "ifaces/networkinterface.h"
00023 #include "ifaces/wirednetworkinterface.h"
00024 #include "ifaces/wirelessnetworkinterface.h"
00025
00026 #include "soliddefs_p.h"
00027 #include "networkmanager_p.h"
00028 #include "networkinterface.h"
00029 #include "wirednetworkinterface.h"
00030 #include "wirelessnetworkinterface.h"
00031
00032 #include "networkmanager.h"
00033
00034 #include <kglobal.h>
00035
00036 K_GLOBAL_STATIC(Solid::Control::NetworkManagerPrivate, globalNetworkManager)
00037
00038 Solid::Control::NetworkManagerPrivate::NetworkManagerPrivate() : m_invalidDevice(0)
00039 {
00040 loadBackend("Network Management",
00041 "SolidNetworkManager",
00042 "Solid::Control::Ifaces::NetworkManager");
00043
00044 if (managerBackend()!=0) {
00045 connect(managerBackend(), SIGNAL(networkInterfaceAdded(const QString &)),
00046 this, SLOT(_k_networkInterfaceAdded(const QString &)));
00047 connect(managerBackend(), SIGNAL(networkInterfaceRemoved(const QString &)),
00048 this, SLOT(_k_networkInterfaceRemoved(const QString &)));
00049 connect(managerBackend(), SIGNAL(statusChanged(Solid::Networking::Status)),
00050 this, SIGNAL(statusChanged(Solid::Networking::Status)));
00051 connect(managerBackend(), SIGNAL(wirelessEnabledChanged(bool)),
00052 this, SIGNAL(wirelessEnabledChanged(bool)));
00053 connect(managerBackend(), SIGNAL(wirelessHardwareEnabledChanged(bool)),
00054 this, SIGNAL(wirelessHardwareEnabledChanged(bool)));
00055 }
00056 }
00057
00058 Solid::Control::NetworkManagerPrivate::~NetworkManagerPrivate()
00059 {
00060
00061 typedef QPair<NetworkInterface *, QObject *> NetworkInterfaceIfacePair;
00062
00063 foreach (const NetworkInterfaceIfacePair &pair, m_networkInterfaceMap.values()) {
00064 delete pair.first;
00065 delete pair.second;
00066 }
00067
00068 m_networkInterfaceMap.clear();
00069 }
00070
00071 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManagerPrivate::buildDeviceList(const QStringList &uniList)
00072 {
00073 NetworkInterfaceList list;
00074 Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00075
00076 if (backend == 0) return list;
00077
00078 foreach (const QString &uni, uniList)
00079 {
00080 QPair<NetworkInterface *, QObject *> pair = findRegisteredNetworkInterface(uni);
00081
00082 if (pair.first!= 0)
00083 {
00084 list.append(pair.first);
00085 }
00086 }
00087
00088 return list;
00089 }
00090
00091 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManagerPrivate::networkInterfaces()
00092 {
00093 Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00094
00095 if (backend!= 0)
00096 {
00097 return buildDeviceList(backend->networkInterfaces());
00098 }
00099 else
00100 {
00101 return NetworkInterfaceList();
00102 }
00103 }
00104
00105 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManager::networkInterfaces()
00106 {
00107 return globalNetworkManager->networkInterfaces();
00108 }
00109
00110 bool Solid::Control::NetworkManager::isNetworkingEnabled()
00111 {
00112 return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isNetworkingEnabled());
00113 }
00114
00115 bool Solid::Control::NetworkManager::isWirelessEnabled()
00116 {
00117 return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isWirelessEnabled());
00118 }
00119
00120 bool Solid::Control::NetworkManager::isWirelessHardwareEnabled()
00121 {
00122 return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isWirelessHardwareEnabled());
00123 }
00124
00125 void Solid::Control::NetworkManager::setNetworkingEnabled(bool enabled)
00126 {
00127 SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), setNetworkingEnabled(enabled));
00128 }
00129
00130 void Solid::Control::NetworkManager::setWirelessEnabled(bool enabled)
00131 {
00132 SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), setWirelessEnabled(enabled));
00133 }
00134
00135 Solid::Networking::Status Solid::Control::NetworkManager::status()
00136 {
00137 return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), Solid::Networking::Unknown, status());
00138 }
00139
00140 Solid::Control::NetworkInterface * Solid::Control::NetworkManagerPrivate::findNetworkInterface(const QString &uni)
00141 {
00142 Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00143
00144 if (backend == 0) return 0;
00145
00146 QPair<NetworkInterface *, QObject *> pair = findRegisteredNetworkInterface(uni);
00147
00148 if (pair.first != 0)
00149 {
00150 return pair.first;
00151 }
00152 else
00153 {
00154 return 0;
00155 }
00156 }
00157
00158 Solid::Control::NetworkInterface * Solid::Control::NetworkManager::findNetworkInterface(const QString &uni)
00159 {
00160 return globalNetworkManager->findNetworkInterface(uni);
00161 }
00162
00163 Solid::Control::NetworkManager::Notifier * Solid::Control::NetworkManager::notifier()
00164 {
00165 return globalNetworkManager;
00166 }
00167
00168 void Solid::Control::NetworkManagerPrivate::_k_networkInterfaceAdded(const QString &uni)
00169 {
00170 QPair<NetworkInterface *, QObject*> pair = m_networkInterfaceMap.take(uni);
00171
00172 if (pair.first!= 0)
00173 {
00174
00175
00176
00177 delete pair.first;
00178 delete pair.second;
00179 }
00180
00181 emit networkInterfaceAdded(uni);
00182 }
00183
00184 void Solid::Control::NetworkManagerPrivate::_k_networkInterfaceRemoved(const QString &uni)
00185 {
00186 QPair<NetworkInterface *, QObject *> pair = m_networkInterfaceMap.take(uni);
00187
00188 if (pair.first!= 0)
00189 {
00190 delete pair.first;
00191 delete pair.second;
00192 }
00193
00194 emit networkInterfaceRemoved(uni);
00195 }
00196
00197 void Solid::Control::NetworkManagerPrivate::_k_destroyed(QObject *object)
00198 {
00199 Ifaces::NetworkInterface *device = qobject_cast<Ifaces::NetworkInterface *>(object);
00200
00201 if (device!=0)
00202 {
00203 QString uni = device->uni();
00204 QPair<NetworkInterface *, QObject *> pair = m_networkInterfaceMap.take(uni);
00205 delete pair.first;
00206 }
00207 }
00208
00209
00210
00211 QPair<Solid::Control::NetworkInterface *, QObject *>
00212 Solid::Control::NetworkManagerPrivate::findRegisteredNetworkInterface(const QString &uni)
00213 {
00214 if (m_networkInterfaceMap.contains(uni)) {
00215 return m_networkInterfaceMap[uni];
00216 } else {
00217 Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00218
00219 if (backend!=0)
00220 {
00221 QObject * iface = backend->createNetworkInterface(uni);
00222 NetworkInterface *device = 0;
00223 if (qobject_cast<Ifaces::WirelessNetworkInterface *>(iface) != 0) {
00224 device = new WirelessNetworkInterface(iface);
00225 } else if (qobject_cast<Ifaces::WiredNetworkInterface *>(iface) != 0) {
00226 device = new WiredNetworkInterface(iface);
00227 }
00228 if (device != 0) {
00229 QPair<NetworkInterface *, QObject *> pair(device, iface);
00230 connect(iface, SIGNAL(destroyed(QObject *)),
00231 this, SLOT(_k_destroyed(QObject *)));
00232 m_networkInterfaceMap[uni] = pair;
00233 return pair;
00234 }
00235 else
00236 {
00237 return QPair<NetworkInterface *, QObject *>(0, 0);
00238 }
00239 }
00240 else
00241 {
00242 return QPair<NetworkInterface *, QObject *>(0, 0);
00243 }
00244 }
00245 }
00246
00247 void Solid::Control::NetworkManager::activateConnection(const QString & interfaceUni, const QString & connectionUni,
00248 const QVariantMap & connectionParameters )
00249 {
00250 SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), activateConnection(interfaceUni, connectionUni, connectionParameters));
00251 }
00252
00253 void Solid::Control::NetworkManager::deactivateConnection(const QString & activeConnectionUni)
00254 {
00255 SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), deactivateConnection(activeConnectionUni));
00256 }
00257
00258 #include "networkmanager_p.moc"
00259 #include "networkmanager.moc"