X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=src%2Fcommon%2Fconnectionmanager.cpp;h=f7b0f32fcbf5611f424494d6bd50422c3e6bc282;hb=d93782e7a5ae0fc072d094fd645cf415a34a2244;hp=f45b0e2e64521f324cb609769d5fd7b3b8525630;hpb=3cf99b9a19050f2fdde9ffd69af65a7d58576ca1;p=jenirok

diff --git a/src/common/connectionmanager.cpp b/src/common/connectionmanager.cpp
index f45b0e2..f7b0f32 100644
--- a/src/common/connectionmanager.cpp
+++ b/src/common/connectionmanager.cpp
@@ -16,19 +16,22 @@
  *
  */
 
-#include <QDebug>
-#include <QApplication>
+#include <QtCore/QDebug>
 #include <QtCore/QTimerEvent>
 #include <QtCore/QVariant>
+#include <QtCore/QStringList>
+#include <QtGui/QApplication>
 #include <QtDBus/QDBusArgument>
+#include <QtDBus/QDBusConnection>
 #include <icd/dbus_api.h>
 #include "connectionmanager.h"
 
+bool ConnectionManager::connected_ = false;
 
 ConnectionManager::ConnectionManager(QObject* parent): QObject(parent),
-blocking_(true), stateReady_(false), connectionReady_(false), scanReady_(false),
-connected_(false), timeout_(false), numberOfConnections_(0),
-scannedConnections_(0), timer_(0), connections_(false)
+stateReady_(false), connectionReady_(false), scanReady_(false),
+timeout_(false), numberOfConnections_(0),
+scannedConnections_(0), timer_(0), searchType_(NO_TYPE), error_(NO_ERROR), connections_(0)
 {
     QDBusConnection systemBus = QDBusConnection::systemBus();
 
@@ -67,75 +70,160 @@ ConnectionManager::~ConnectionManager()
                          this, SLOT(scanResult(const QDBusMessage&)));
 }
 
-void ConnectionManager::setBlocking(bool value)
-{
-    blocking_ = value;
-}
-
 bool ConnectionManager::connect()
 {
     connectionReady_ = false;
     unsigned int flags = static_cast<unsigned int>(ICD_CONNECTION_FLAG_USER_EVENT);
     icd2interface_->call(ICD_DBUS_API_CONNECT_REQ, QVariant(flags));
 
-    if(blocking_)
+    waitSignal(&connectionReady_);
+
+    if(connected_)
     {
-        waitSignal(&connectionReady_);
-        return connected_;
+        sleep(WAIT_AFTER_CONNECT);
     }
 
-    return true;
+    return connected_;
 }
 
 bool ConnectionManager::connect(ConnectionManager::Connection const& connection)
 {
-    connectionReady_ = false;
-    QDBusArgument arg;
-    arg.beginStructure();
-    arg << connection.serviceType
-        << connection.serviceAttributes
-        << connection.serviceID
-        << connection.networkType
-        << connection.networkAttributes
-        << connection.networkID;
-    arg.endStructure();
+    return connect(connection.id);
+}
 
-    unsigned int flags = static_cast<unsigned int>(ICD_CONNECTION_FLAG_USER_EVENT);
-    QDBusMessage rep = icd2interface_->call(ICD_DBUS_API_CONNECT_REQ,
-                                            flags, arg.asVariant());
+bool ConnectionManager::connect(QString const& id)
+{
+    QDBusMessage msg = QDBusMessage::createMethodCall("com.nokia.icd",
+                                                      "/com/nokia/icd",
+                                                      "com.nokia.icd",
+                                                      "connect");
+    QList<QVariant> arguments;
+
+    arguments.append(QVariant(id));
+
+    unsigned int val = 0;
+
+    arguments.append(QVariant(val));
+
+    msg.setArguments(arguments);
 
-    qDebug() << rep.errorName() << rep.errorMessage();
+    QDBusMessage rep = QDBusConnection::systemBus().call(msg);
 
-    if(blocking_)
+    if(rep.type() == QDBusMessage::ErrorMessage)
     {
-        waitSignal(&connectionReady_);
-        return connected_;
+        if(rep.errorName() == "com.nokia.icd.error.invalid_iap")
+        {
+            error_ = INVALID_IAP;
+        }
+        else
+        {
+            error_ = UNKNOWN_ERROR;
+        }
+
+        connected_ = false;
+
+        return false;
     }
 
+    connected_ = true;
+
+    sleep(WAIT_AFTER_CONNECT);
+
     return true;
 }
 
-bool ConnectionManager::disconnect(bool force)
+bool ConnectionManager::getBestConnection(Connection& connection, ConnectionType type)
 {
-    // Forced disconnect is not allowed if connection
-    // was not initialized by this class
-    if(!connected_ && force)
+    QList<Connection> connections;
+
+    if(!scanConnections(connections))
     {
+        qDebug() << "Unable to scan connections";
         return false;
     }
 
-    connectionReady_ = false;
-    unsigned int flags;
+    if(connections.size() == 0)
+    {
+        error_ = NO_AVAILABLE_CONNECTIONS;
+        return false;
+    }
 
-    if(force)
+    int biggestWlan = -1;
+    int biggestGprs = -1;
+    int bestWlan = -1;
+    int bestGprs = -1;
+
+    for(int i = 0; i < connections.size(); i++)
     {
-        flags = static_cast<unsigned int>(ICD_CONNECTION_FLAG_UI_EVENT);
+        switch(connections.at(i).type)
+        {
+        case WLAN:
+            if(type != GPRS && connections.at(i).strength > biggestWlan)
+            {
+                biggestWlan = connections.at(i).strength;
+                bestWlan = i;
+            }
+            break;
+
+        case GPRS:
+            if(type != WLAN && connections.at(i).strength > biggestGprs)
+            {
+                biggestGprs = connections.at(i).strength;
+                bestGprs = i;
+            }
+            break;
+
+        default:
+            qDebug() << "Unknown connection type";
+        }
+    }
+
+    if(bestWlan >= 0)
+    {
+        connection = connections.at(bestWlan);
+        return true;
+    }
+    else if(bestGprs >= 0)
+    {
+        connection = connections.at(bestGprs);
+        return true;
     }
     else
     {
-        flags = static_cast<unsigned int>(ICD_CONNECTION_FLAG_USER_EVENT);
+        error_ = NO_AVAILABLE_CONNECTIONS;
+        return false;
     }
 
+}
+
+bool ConnectionManager::disconnect(bool force)
+{
+    if(force)
+    {
+        QDBusMessage msg = QDBusMessage::createSignal("/com/nokia/icd_ui",
+                                                      "com.nokia.icd_ui",
+                                                      "disconnect");
+
+        QList<QVariant> arguments;
+        bool val = true;
+        arguments.append(QVariant(val));
+        msg.setArguments(arguments);
+
+        bool ret = QDBusConnection::systemBus().send(msg);
+
+        if(ret)
+        {
+            connected_ = false;
+        }
+
+        return ret;
+    }
+
+    connectionReady_ = false;
+    unsigned int flags;
+
+    flags = static_cast<unsigned int>(ICD_CONNECTION_FLAG_USER_EVENT);
+
     icd2interface_->call(ICD_DBUS_API_DISCONNECT_REQ, QVariant(flags));
     connected_ = false;
     return true;
@@ -150,43 +238,43 @@ bool ConnectionManager::isConnected()
 
     if(numOfReplies == 0)
     {
-        emit isConnectedReply(false);
         return false;
     }
 
-    if(blocking_)
-    {
-        waitSignal(&stateReady_);
-        return connected_;
-    }
-
-    return true;
+    waitSignal(&stateReady_);
+    return connected_;
 }
 
-bool ConnectionManager::scanConnections(QList<ConnectionManager::Connection>& connections)
+bool ConnectionManager::scanConnections(QList<ConnectionManager::Connection>& connections,
+                                        ConnectionManager::ConnectionType type)
 {
-    unsigned int flags = static_cast<unsigned int>(ICD_SCAN_REQUEST_ACTIVE);
+    unsigned int flags = static_cast<unsigned int>(ICD_SCAN_REQUEST_ACTIVE_SAVED);
     scanReady_ = false;
     scannedConnections_ = 0;
     connections_ = &connections;
-    QDBusMessage rep = icd2interface_->call(ICD_DBUS_API_SCAN_REQ, QVariant(flags));
+    searchType_ = type;
+
+    QDBusMessage rep = icd2interface_->call(ICD_DBUS_API_SCAN_REQ,
+                                            QVariant(flags));
 
     numberOfConnections_ = rep.arguments().value(0).toList().size();
 
+    // For some reason, during call icd2 doesn't return any connections
+    // it is going to scan. However, it still scans them so use default value
+    // of 2.
     if(numberOfConnections_ == 0)
     {
-        connections_ = 0;
-        return false;
+        numberOfConnections_ = 2;
     }
 
-    if(blocking_)
-    {
-        bool ret = waitSignal(&scanReady_);
-        connections_ = 0;
-        return ret;
-    }
+    bool ret = waitSignal(&scanReady_);
+    connections_ = 0;
+    return ret;
+}
 
-    return true;
+ConnectionManager::Error ConnectionManager::error() const
+{
+    return error_;
 }
 
 void ConnectionManager::stateChange(const QDBusMessage& rep)
@@ -226,11 +314,6 @@ void ConnectionManager::stateChange(const QDBusMessage& rep)
         break;
     }
 
-    if(stateReady_)
-    {
-        emit isConnectedReply(connected_);
-    }
-
 }
 
 void ConnectionManager::connectionChange(const QDBusMessage& rep)
@@ -256,10 +339,6 @@ void ConnectionManager::connectionChange(const QDBusMessage& rep)
         break;
     }
 
-    if(connectionReady_)
-    {
-        emit connectReply(connected_);
-    }
 }
 
 void ConnectionManager::scanResult(const QDBusMessage& rep)
@@ -281,25 +360,59 @@ void ConnectionManager::scanResult(const QDBusMessage& rep)
     if(scannedConnections_ >= numberOfConnections_)
     {
         scanReady_ = true;
-        emit scanReady();
+        connections_ = 0;
         return;
     }
 
-    if(status != ICD_SCAN_NEW)
+    if(status != ICD_SCAN_NEW && status != ICD_SCAN_NOTIFY)
     {
         return;
     }
 
     Connection connection;
-    connection.serviceType = args.value(2).toString();
-    connection.serviceAttributes = args.value(4).value<unsigned int>();
-    connection.serviceID = args.value(5).toString();
-    connection.networkName = args.value(8).toString();
-    connection.networkType = args.value(7).toString();
-    connection.networkAttributes = args.value(9).value<unsigned int>();
-    connection.networkID = args.value(10).toByteArray();
 
-    emit newConnection(connection);
+    QString type = args.value(7).toString();
+
+    if(type == "GPRS")
+    {
+        if(searchType_ == WLAN)
+        {
+            return;
+        }
+
+        connection.type = GPRS;
+    }
+    else if(type == "WLAN_INFRA" || type == "WLAN_ADHOC")
+    {
+        if(searchType_ == GPRS)
+        {
+            return;
+        }
+
+        connection.type = WLAN;
+    }
+    else
+    {
+        qDebug() << "Unknown connection type: " << type;
+        return;
+    }
+
+    connection.id = QString(args.value(10).toByteArray());
+    connection.name = args.value(8).toString();
+    connection.strength = args.value(11).toInt();
+
+    for(int i = 0; i < connections_->size(); i++)
+    {
+        if(connections_->at(i).id == connection.id)
+        {
+            if(status == ICD_SCAN_NEW)
+            {
+                connections_->replace(i, connection);
+            }
+
+            return;
+        }
+    }
 
     connections_->push_back(connection);
 }
@@ -316,15 +429,31 @@ bool ConnectionManager::waitSignal(bool* ready)
 
     killTimer(timer_);
 
+    if(timeout_)
+    {
+        qDebug() << "Connection request timed out";
+    }
+
     return *ready || !timeout_;
 }
 
+void ConnectionManager::sleep(unsigned int ms)
+{
+    timeout_ = false;
+    timer_ = startTimer(ms);
+
+    while(!timeout_)
+    {
+        QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
+    }
+
+    killTimer(timer_);
+}
+
 void ConnectionManager::timerEvent(QTimerEvent* event)
 {
     Q_UNUSED(event);
     killTimer(timer_);
     timeout_ = true;
     timer_ = 0;
-
-    qDebug() << "Connection request timed out";
 }