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 #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
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
00181
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"