X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=src%2Fsituareservice%2Fsituareservice.cpp;h=5bbb36ebed18c253b050a70ba96aefb24045b954;hb=b72d0f2174bd17a5016936a1cbf90dcd912c1d8a;hp=0c8d52ee99a181325cede6e0a7e64437600584dc;hpb=7833964f96e1c9315f6fadd44c189f98f7201041;p=situare

diff --git a/src/situareservice/situareservice.cpp b/src/situareservice/situareservice.cpp
index 0c8d52e..5bbb36e 100644
--- a/src/situareservice/situareservice.cpp
+++ b/src/situareservice/situareservice.cpp
@@ -19,18 +19,21 @@
    USA.
 */
 
-#include <QtAlgorithms>
+#include <qjson/parser.h>
+
 #include <QDebug>
-#include <QtGlobal>
-#include <QStringList>
-#include <QPixmap>
 #include <QNetworkReply>
-#include "situareservice.h"
+#include <QPixmap>
+#include <QStringList>
+#include <QtAlgorithms>
+#include <QtGlobal>
+
+#include "error.h"
+#include "network/networkaccessmanager.h"
 #include "situarecommon.h"
-#include "common.h"
-#include "parser.h"
 #include "ui/avatarimage.h"
-#include "network/networkaccessmanager.h"
+
+#include "situareservice.h"
 
 SituareService::SituareService(QObject *parent)
         : QObject(parent),
@@ -38,17 +41,17 @@ SituareService::SituareService(QObject *parent)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    m_networkManager = NetworkAccessManager::instance();
+    m_networkManager = new NetworkAccessManager(this);
     connect(m_networkManager, SIGNAL(finished(QNetworkReply*)),
-            this, SLOT(requestFinished(QNetworkReply*)));
+            this, SLOT(requestFinished(QNetworkReply*)), Qt::QueuedConnection);
 
-    m_imageFetcher = new ImageFetcher(NetworkAccessManager::instance(), this);
+    m_imageFetcher = new ImageFetcher(new NetworkAccessManager(this), this);
     connect(this, SIGNAL(fetchImage(QUrl)),
             m_imageFetcher, SLOT(fetchImage(QUrl)));
     connect(m_imageFetcher, SIGNAL(imageReceived(QUrl,QPixmap)),
             this, SLOT(imageReceived(QUrl, QPixmap)));
-    connect(m_imageFetcher, SIGNAL(error(int)),
-            this, SIGNAL(error(int)));
+    connect(m_imageFetcher, SIGNAL(error(int, int)),
+            this, SIGNAL(error(int, int)));
 }
 
 SituareService::~SituareService()
@@ -64,53 +67,93 @@ SituareService::~SituareService()
     m_friendsList.clear();
 }
 
-void SituareService::fetchLocations()
+void SituareService::addProfileImages(const QList<QUrl> &imageUrlList)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    QString cookie = formCookie(API_KEY, m_credentials.expires(), m_credentials.userID(),
-                                m_credentials.sessionKey(), m_credentials.sessionSecret(),
-                                m_credentials.sig(), EN_LOCALE);
+    foreach(QUrl url, imageUrlList) {
+        emit fetchImage(url);
+    }
+}
+
+void SituareService::appendAccessToken(QString &requestUrl)
+{
+    qWarning() << __PRETTY_FUNCTION__;
 
-    QUrl url = formUrl(SITUARE_URL, GET_LOCATIONS);
-    sendRequest(url, COOKIE, cookie);
+    requestUrl.append(m_session);
 }
 
-void SituareService::reverseGeo(const QPointF &coordinates)
+void SituareService::buildRequest(const QString &script, const QHash<QString, QString> &parameters)
 {
-    qDebug() << __PRETTY_FUNCTION__;
+    qWarning() << __PRETTY_FUNCTION__;
+
+    const QString PARAMETER_KEY_API = "api";
+    const QString PARAMETER_VALUE_API = "2.0";
+
+    QString url = SITUARE_URL;
+    url.append(script);
+    url.append("?");
+
+    // append default api version parameter if not yet specified
+//    if (!parameters.contains(PARAMETER_KEY_API))
+//        url.append(PARAMETER_KEY_API + "=" + PARAMETER_VALUE_API + "&");
+
+    // append parameters
+    if (!parameters.isEmpty()) {
+        QHash<QString, QString>::const_iterator i = parameters.constBegin();
+        while (i != parameters.constEnd()) {
+            url.append(i.key());
+            url.append("=");
+            url.append(i.value());
+            url.append("&");
+            i++;
+        }
+    }
+
+//    qWarning() << __PRETTY_FUNCTION__ << "request url with parameters:" << url;
+
+    if (!m_session.isEmpty()) {
+        appendAccessToken(url);
+        sendRequest(url);
+    } else {
+        m_requestsWaitingAccessToken.append(url);
+        ///< @todo emit login request
+    }
+}
 
-    QString cookie = formCookie(API_KEY, m_credentials.expires(),m_credentials.userID(),
-                                m_credentials.sessionKey(), m_credentials.sessionSecret(),
-                                m_credentials.sig(), EN_LOCALE);
+void SituareService::clearUserData()
+{
+    qDebug() << __PRETTY_FUNCTION__;
 
-    QString urlParameters = formUrlParameters(coordinates);
-    QUrl url = formUrl(SITUARE_URL, REVERSE_GEO, urlParameters);
+    qDeleteAll(m_friendsList.begin(), m_friendsList.end());
+    m_friendsList.clear();
 
-    sendRequest(url, COOKIE, cookie);
+    if(m_user) {
+        delete m_user;
+        m_user = 0;
+    }
+    emit userDataChanged(m_user, m_friendsList);
 }
 
-void SituareService::updateLocation(const QPointF &coordinates, const QString &status,
-                                    const bool &publish)
+QString SituareService::degreesToString(double degrees)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    QString cookie = formCookie(API_KEY, m_credentials.expires(), m_credentials.userID(),
-                                m_credentials.sessionKey(), m_credentials.sessionSecret(),
-                                m_credentials.sig(), EN_LOCALE);
+    // one scene pixel is about 5.4e-6 degrees, the integer part is max three digits and one
+    // additional digit is added for maximum precision
+    const int PRECISION = 10;
+
+    return QString::number(degrees, 'f', PRECISION);
+}
 
+void SituareService::fetchLocations()
+{
+    qDebug() << __PRETTY_FUNCTION__;
 
-    QString publishValue;
-    if(publish) {
-        publishValue = PUBLISH_TRUE;
-    }
-    else {
-        publishValue = PUBLISH_FALSE;
-    }
-    QString urlParameters = formUrlParameters(coordinates, status, publishValue);
-    QUrl url = formUrl(SITUARE_URL, UPDATE_LOCATION, urlParameters);
+    QHash<QString, QString> parameters;
+    parameters.insert("extra_user_data", NORMAL_SIZE_PROFILE_IMAGE);
 
-    sendRequest(url, COOKIE, cookie);
+    buildRequest(GET_LOCATIONS, parameters);
 }
 
 QString SituareService::formCookie(const QString &apiKeyValue, QString expiresValue,
@@ -187,31 +230,29 @@ QUrl SituareService::formUrl(const QString &baseUrl, const QString &phpScript,
     return url;
 }
 
-QString SituareService::formUrlParameters(const QPointF &coordinates, QString status,
-                                          QString publish)
+QString SituareService::formUrlParameters(const GeoCoordinate &coordinates, QString status,
+                                          bool publish)
 {
-    QString parameters;
+    qDebug() << __PRETTY_FUNCTION__;
 
+    QString parameters;
     parameters.append(QUESTION_MARK);
     parameters.append(LATITUDE);
     parameters.append(EQUAL_MARK);
-    parameters.append(QString::number(coordinates.y()));
+    parameters.append(degreesToString(coordinates.latitude()));
     parameters.append(AMBERSAND_MARK);
     parameters.append(LONGTITUDE);
     parameters.append(EQUAL_MARK);
-    parameters.append(QString::number(coordinates.x()));
+    parameters.append(degreesToString(coordinates.longitude()));
 
-    if(publish.compare(PUBLISH_TRUE) == 0) {
-        parameters.append(AMBERSAND_MARK);
-        parameters.append(PUBLISH);
-        parameters.append(EQUAL_MARK);
+    parameters.append(AMBERSAND_MARK);
+    parameters.append(PUBLISH);
+    parameters.append(EQUAL_MARK);
+
+    if(publish)
         parameters.append(PUBLISH_TRUE);
-    } else if(publish.compare(PUBLISH_FALSE) == 0) {
-        parameters.append(AMBERSAND_MARK);
-        parameters.append(PUBLISH);
-        parameters.append(EQUAL_MARK);
+    else
         parameters.append(PUBLISH_FALSE);
-    }
 
     if(!status.isEmpty()) {
         parameters.append(AMBERSAND_MARK);
@@ -223,19 +264,196 @@ QString SituareService::formUrlParameters(const QPointF &coordinates, QString st
     return parameters;
 }
 
-void SituareService::sendRequest(const QUrl &url, const QString &cookieType, const QString &cookie)
+void SituareService::imageReceived(const QUrl &url, const QPixmap &image)
 {
     qDebug() << __PRETTY_FUNCTION__;
+    qDebug() << "Image URL: " << url << " size :" << image.size();
 
-    QNetworkRequest request;
+    // assign facebook silhouette image to all who doesn't have a profile image
+    if(url == QUrl(SILHOUETTE_URL)) {
+        if(m_user->profileImageUrl().isEmpty()) {
+            m_user->setProfileImage(AvatarImage::create(image, AvatarImage::Large));
+            emit imageReady(m_user);
+        }
+        foreach(User *friendItem, m_friendsList) {
+            if(friendItem->profileImageUrl().isEmpty()) {
+                friendItem->setProfileImage(AvatarImage::create(image, AvatarImage::Small));
+                emit imageReady(friendItem);
+            }
+        }
+    }
 
-    request.setUrl(url);
-    request.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
-    request.setRawHeader(cookieType.toAscii(), cookie.toUtf8());
+    if (m_user->profileImageUrl() == url) {
+        m_user->setProfileImage(AvatarImage::create(image, AvatarImage::Large));
+        emit imageReady(m_user);
+    }
 
-    QNetworkReply *reply = m_networkManager->get(request);
+    foreach(User *friendItem, m_friendsList) {
+        if(friendItem->profileImageUrl() == url) {
+            friendItem->setProfileImage(AvatarImage::create(image, AvatarImage::Small));
+            emit imageReady(friendItem);
+        }
+    }
+}
 
-    m_currentRequests.append(reply);
+void SituareService::parseUserData(const QByteArray &jsonReply)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    m_defaultImage = false;
+
+    QJson::Parser parser;
+    bool ok;
+
+    QVariantMap result = parser.parse (jsonReply, &ok).toMap();
+    if (!ok) {
+        emit error(ErrorContext::SITUARE, SituareError::INVALID_JSON);
+        return;
+    } else {
+
+        if(result.contains("ErrorCode")) {
+            QVariant errorVariant = result.value("ErrorCode");
+            emit error(ErrorContext::SITUARE, errorVariant.toInt());
+            return;
+        } else if(result.contains("user")) {
+
+            QVariant userVariant = result.value("user");
+            QMap<QString, QVariant> userMap = userVariant.toMap();
+
+            GeoCoordinate coordinates(userMap["latitude"].toReal(), userMap["longitude"].toReal());
+
+            QUrl imageUrl = userMap[NORMAL_SIZE_PROFILE_IMAGE].toUrl();
+
+            if(imageUrl.isEmpty()) {
+                // user doesn't have profile image, so we need to get him a silhouette image
+                m_defaultImage = true;
+            }
+
+            QString address = userMap["address"].toString();
+            if(address.isEmpty()) {
+                QStringList location;
+                location.append(QString::number(coordinates.latitude()));
+                location.append(QString::number(coordinates.longitude()));
+                address = location.join(", ");
+            }
+
+            User user = User(address, coordinates, userMap["name"].toString(),
+                          userMap["note"].toString(), imageUrl, userMap["timestamp"].toString(),
+                          true, userMap["uid"].toString());
+
+            QList<User> tmpFriendsList;
+
+            foreach (QVariant friendsVariant, result["friends"].toList()) {
+              QMap<QString, QVariant> friendMap = friendsVariant.toMap();
+              QVariant distance = friendMap["distance"];
+              QMap<QString, QVariant> distanceMap = distance.toMap();
+
+              GeoCoordinate coordinates(friendMap["latitude"].toReal(),friendMap["longitude"].toReal());
+
+              QUrl imageUrl = friendMap["profile_pic"].toUrl();
+
+              if(imageUrl.isEmpty()) {
+                  // friend doesn't have profile image, so we need to get him a silhouette image
+                  m_defaultImage = true;
+              }
+
+              QString address = friendMap["address"].toString();
+              if(address.isEmpty()) {
+                  QStringList location;
+                  location.append(QString::number(coordinates.latitude()));
+                  location.append(QString::number(coordinates.longitude()));
+                  address = location.join(", ");
+              }
+
+              User buddy = User(address, coordinates, friendMap["name"].toString(),
+                               friendMap["note"].toString(), imageUrl,
+                               friendMap["timestamp"].toString(),
+                               false, friendMap["uid"].toString(), distanceMap["units"].toString(),
+                               distanceMap["value"].toDouble());
+
+              tmpFriendsList.append(buddy);
+            }
+
+            QList<QUrl> imageUrlList; // url list for images
+
+            // set unchanged profile images or add new images to imageUrlList for downloading
+            if(m_user) {
+                if(m_user->profileImageUrl() != user.profileImageUrl()) {
+                    if(!user.profileImageUrl().isEmpty())
+                        imageUrlList.append(user.profileImageUrl());
+                } else {
+                    user.setProfileImage(m_user->profileImage());
+                }
+            } else {
+                if(!user.profileImageUrl().isEmpty())
+                    imageUrlList.append(user.profileImageUrl());
+            }
+
+            // clear old user object
+            if(m_user) {
+                delete m_user;
+                m_user = 0;
+            }
+
+            // create new user object from temporary user object
+            m_user = new User(user);
+
+            // set unchanged profile images or add new images to imageUrlList for downloading
+            if(!m_friendsList.isEmpty()) {
+                foreach(User tmpBuddy, tmpFriendsList) {
+                    if(!tmpBuddy.profileImageUrl().isEmpty()) {
+                        bool found = false;
+                        foreach(User *buddy, m_friendsList) {
+                            if(tmpBuddy.profileImageUrl() == buddy->profileImageUrl()) {
+                                tmpBuddy.setProfileImage(buddy->profileImage());
+                                found = true;
+                                break;
+                            }
+                        }
+                        if(!found && !tmpBuddy.profileImageUrl().isEmpty())
+                            imageUrlList.append(tmpBuddy.profileImageUrl());
+                    }
+                }
+            } else {
+                foreach(User buddy, tmpFriendsList) {
+                    if(!buddy.profileImageUrl().isEmpty())
+                        imageUrlList.append(buddy.profileImageUrl());
+                }
+            }
+
+            // clear old friendlist
+            qDeleteAll(m_friendsList.begin(), m_friendsList.end());
+            m_friendsList.clear();
+
+            // populate new friendlist with temporary friendlist's data
+            foreach(User tmpFriendItem, tmpFriendsList) {
+                User *friendItem = new User(tmpFriendItem);
+                m_friendsList.append(friendItem);
+            }
+            tmpFriendsList.clear();
+
+            emit userDataChanged(m_user, m_friendsList);
+
+            // set silhouette image to imageUrlList for downloading
+            if(m_defaultImage)
+                imageUrlList.append(QUrl(SILHOUETTE_URL));
+
+            addProfileImages(imageUrlList);
+            imageUrlList.clear();
+        } else {
+            QVariant address = result.value("address");
+            if(!address.toString().isEmpty()) {
+                emit reverseGeoReady(address.toString());
+            } else {
+                QStringList coordinates;
+                coordinates.append(result.value("lat").toString());
+                coordinates.append(result.value("lon").toString());
+
+                emit error(ErrorContext::SITUARE, SituareError::ADDRESS_RETRIEVAL_FAILED);
+                emit reverseGeoReady(coordinates.join(", "));
+            }
+        }
+    }
 }
 
 void SituareService::requestFinished(QNetworkReply *reply)
@@ -245,39 +463,36 @@ void SituareService::requestFinished(QNetworkReply *reply)
     //Reply from situare
     if (m_currentRequests.contains(reply)) {
 
-        QUrl url = reply->url();
         qDebug() << "BytesAvailable: " << reply->bytesAvailable();
 
         if (reply->error()) {
-            emit error(reply->error());
+            emit error(ErrorContext::NETWORK, reply->error());
         } else {
-            qint64 max = reply->size();
-            QByteArray replyArray = reply->read(max);
-            qDebug() << "Reply from: " << url << "reply " << replyArray;
+            QByteArray replyArray = reply->readAll();
+            qDebug() << "Reply from: " << reply->url() << "reply " << replyArray;
 
             if(replyArray == ERROR_LAT.toAscii()) {
                 qDebug() << "Error: " << ERROR_LAT;
-                emit error(SituareError::UPDATE_FAILED);
+                emit error(ErrorContext::SITUARE, SituareError::UPDATE_FAILED);
             } else if(replyArray == ERROR_LON.toAscii()) {
                 qDebug() << "Error: " << ERROR_LON;
-                emit error(SituareError::UPDATE_FAILED);
+                emit error(ErrorContext::SITUARE, SituareError::UPDATE_FAILED);
             } else if(replyArray.contains(ERROR_SESSION.toAscii())) {
                 qDebug() << "Error: " << ERROR_SESSION;
-                emit error(SituareError::SESSION_EXPIRED);
+                emit error(ErrorContext::SITUARE, SituareError::SESSION_EXPIRED);
             } else if(replyArray.startsWith(OPENING_BRACE_MARK.toAscii())) {
                 qDebug() << "JSON string";
                 parseUserData(replyArray);
             } else if(replyArray.isEmpty()) {
-                if(url.toString().contains(UPDATE_LOCATION.toAscii())) {
+                if(reply->url().toString().contains(UPDATE_LOCATION.toAscii())) {
                     emit updateWasSuccessful();
                 } else {
                     // session credentials are invalid
-                    emit error(SituareError::SESSION_EXPIRED);
+                    emit error(ErrorContext::SITUARE, SituareError::SESSION_EXPIRED);
                 }
             } else {
-                // Street address ready
-                QString address = QString::fromUtf8(replyArray);
-                emit reverseGeoReady(address);
+                // unknown reply
+                emit error(ErrorContext::SITUARE, SituareError::ERROR_GENERAL);
             }
         }
         m_currentRequests.removeAll(reply);
@@ -285,148 +500,74 @@ void SituareService::requestFinished(QNetworkReply *reply)
     }
 }
 
-void SituareService::credentialsReady(const FacebookCredentials &credentials)
+void SituareService::reverseGeo(const GeoCoordinate &coordinates)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    m_credentials = credentials;    
+    QHash<QString, QString> parameters;
+    parameters.insert("lat", degreesToString(coordinates.latitude()));
+    parameters.insert("lon", degreesToString(coordinates.longitude()));
+    parameters.insert("format", "json");
+
+    buildRequest(REVERSE_GEO, parameters);
 }
 
-void SituareService::parseUserData(const QByteArray &jsonReply)
+void SituareService::sendRequest(const QUrl &url, const QString &cookieType, const QString &cookie)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    m_visited = 0;
-    m_nbrOfImages = 0;
-    m_defaultImage = false;
-    qDeleteAll(m_friendsList.begin(), m_friendsList.end());
-    m_friendsList.clear();
-
-    if(m_user) {
-        delete m_user;
-        m_user = 0;
-    }
-
-    QJson::Parser parser;
-    bool ok;
-
-    QVariantMap result = parser.parse (jsonReply, &ok).toMap();
-    if (!ok) {
-
-        qFatal("An error occurred during parsing");
-        exit (1);
-    }
-
-    QVariant userVariant = result.value("user");
-    QMap<QString, QVariant> userMap = userVariant.toMap();
-
-    QPointF coordinates(userMap["longitude"].toReal(), userMap["latitude"].toReal());
-
-    QUrl imageUrl = userMap[NORMAL_SIZE_PROFILE_IMAGE].toUrl();
-
-    if(imageUrl.isEmpty()) {
-        // user doesn't have profile image, so we need to get him a silhouette image
-        m_defaultImage = true;
-    }
-
-    m_user = new User(userMap["address"].toString(), coordinates, userMap["name"].toString(),
-                  userMap["note"].toString(), imageUrl, userMap["timestamp"].toString(),
-                  true, userMap["uid"].toString());
-
-    foreach (QVariant friendsVariant, result["friends"].toList()) {
-      QMap<QString, QVariant> friendMap = friendsVariant.toMap();
-      QVariant distance = friendMap["distance"];
-      QMap<QString, QVariant> distanceMap = distance.toMap();
-
-      QPointF coordinates(friendMap["longitude"].toReal(), friendMap["latitude"].toReal());
-
-      QUrl imageUrl = friendMap["profile_pic"].toUrl();
+    QNetworkRequest request;
 
-      if(imageUrl.isEmpty()) {
-          // friend doesn't have profile image, so we need to get him a silhouette image
-          m_defaultImage = true;
-      }
+    request.setUrl(url);
+    request.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
+    request.setRawHeader(cookieType.toAscii(), cookie.toUtf8());
 
-      User *user = new User(friendMap["address"].toString(), coordinates,
-                            friendMap["name"].toString(),
-                            friendMap["note"].toString(), imageUrl,
-                            friendMap["timestamp"].toString(),
-                            false, friendMap["uid"].toString(),
-                            distanceMap["units"].toString(),
-                            distanceMap["value"].toDouble());
+    QNetworkReply *reply = m_networkManager->get(request, true);
 
-      m_friendsList.append(user);
-    }
-    addProfileImages();
+    m_currentRequests.append(reply);
 }
 
-void SituareService::imageReceived(const QUrl &url, const QPixmap &image)
+void SituareService::sendRequest(const QString &requestUrl)
 {
-    qDebug() << __PRETTY_FUNCTION__;
-    qDebug() << "Image URL: " << url << " size :" << image.size();
+    qWarning() << __PRETTY_FUNCTION__ << "requestUrl" << requestUrl;
 
-    // assign facebook silhouette image to all who doesn't have a profile image
-    if(url == QUrl(SILHOUETTE_URL)) {
-        if(m_user->profileImageUrl().isEmpty()) {
-            m_user->setProfileImage(AvatarImage::create(image, AvatarImage::Large));
-        }
-        for(int i=0;i < m_friendsList.count();i++) {
-            if(m_friendsList.at(i)->profileImageUrl().isEmpty()) {
-                m_friendsList.at(i)->setProfileImage(AvatarImage::create(image,
-                                                                         AvatarImage::Small));
-            }
-        }
-    }
-
-    if (m_user->profileImageUrl() == url) {
-        m_user->setProfileImage(AvatarImage::create(image, AvatarImage::Large));
-    }
-
-    for(int i=0;i<m_friendsList.count();i++) {
-        if(m_friendsList.at(i)->profileImageUrl() == url) {
-            m_friendsList.at(i)->setProfileImage(AvatarImage::create(image, AvatarImage::Small));
-            m_nbrOfImages++; // indicates how many friend profile images has been downloaded
-        }
-    }
-
-    if(m_nbrOfImages == m_visited) {
-        qDebug() << "m_nbrOfImages: " << m_nbrOfImages << " m_visited: " << m_visited;
-        qDebug() << "emit userDataChanged";
-        emit userDataChanged(m_user, m_friendsList);
-    }
+    // make and send the request
+    QNetworkRequest request;
+    request.setUrl(QUrl(requestUrl));
+    request.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
+    QNetworkReply *reply = m_networkManager->get(request, true);
+    m_currentRequests.append(reply);
 }
 
-void SituareService::addProfileImages()
+void SituareService::updateSession(const QString &session)
 {
-    qDebug() << __PRETTY_FUNCTION__;
-
-    // reduce net traffic by sending only one download request for facebook silhouette image
-    if(m_defaultImage) {
-        emit fetchImage(QUrl(SILHOUETTE_URL));
-    }
+    qWarning() << __PRETTY_FUNCTION__;
 
-    if(!m_user->profileImageUrl().isEmpty() && m_user->profileImageUrl().isValid())
-        emit fetchImage(m_user->profileImageUrl());
+    m_session = session;
 
-    for(int i=0;i<m_friendsList.count();i++) {
-        if(!m_friendsList.at(i)->profileImageUrl().isEmpty() &&
-           m_friendsList.at(i)->profileImageUrl().isValid()) {
-            m_visited++; // indicates how many friends that have profile image
-            emit fetchImage(m_friendsList.at(i)->profileImageUrl());
+    if (!m_session.isEmpty()) {
+        foreach (QString request, m_requestsWaitingAccessToken) {
+            appendAccessToken(request);
+            sendRequest(request);
         }
     }
+    else {
+        clearUserData();
+    }
+
+    m_requestsWaitingAccessToken.clear();
 }
 
-void SituareService::clearUserData()
+void SituareService::updateLocation(const GeoCoordinate &coordinates, const QString &status,
+                                    const bool &publish)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    qDeleteAll(m_friendsList.begin(), m_friendsList.end());
-    m_friendsList.clear();
+    QHash<QString, QString> parameters;
+    parameters.insert("lat", degreesToString(coordinates.latitude()));
+    parameters.insert("lon", degreesToString(coordinates.longitude()));
+    parameters.insert("publish", publish ? "true" : "false");
+    parameters.insert("data", status); ///< @todo if !empty ???
 
-    if(m_user) {
-        delete m_user;
-        m_user = 0;
-    }
-    emit userDataChanged(m_user, m_friendsList);
+    buildRequest(UPDATE_LOCATION, parameters);
 }