git.maemo.org Git - situare/blob - src/situareservice/situareservice.cpp

   1 /*
   2    Situare - A location system for Facebook
   3    Copyright (C) 2010  Ixonos Plc. Authors:
   4
   5       Henri Lampela - henri.lampela@ixonos.com
   6
   7    Situare is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU General Public License
   9    version 2 as published by the Free Software Foundation.
  10
  11    Situare is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with Situare; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  19    USA.
  20 */
  21
  22 #include <QtAlgorithms>
  23 #include <QDebug>
  24 #include <QtGlobal>
  25 #include <QStringList>
  26 #include <QPixmap>
  27 #include <QNetworkReply>
  28 #include "situareservice.h"
  29 #include "situarecommon.h"
  30 #include "common.h"
  31 #include "parser.h"
  32 #include "ui/avatarimage.h"
  33 #include "network/networkaccessmanager.h"
  34
  35 SituareService::SituareService(QObject *parent)
  36         : QObject(parent),
  37         m_user(0)
  38 {
  39     qDebug() << __PRETTY_FUNCTION__;
  40
  41     m_networkManager = new NetworkAccessManager(this);
  42     connect(m_networkManager, SIGNAL(finished(QNetworkReply*)),
  43             this, SLOT(requestFinished(QNetworkReply*)), Qt::QueuedConnection);
  44
  45     m_imageFetcher = new ImageFetcher(new NetworkAccessManager(this), this);
  46     connect(this, SIGNAL(fetchImage(QUrl)),
  47             m_imageFetcher, SLOT(fetchImage(QUrl)));
  48     connect(m_imageFetcher, SIGNAL(imageReceived(QUrl,QPixmap)),
  49             this, SLOT(imageReceived(QUrl, QPixmap)));
  50     connect(m_imageFetcher, SIGNAL(error(int, int)),
  51             this, SIGNAL(error(int, int)));
  52 }
  53
  54 SituareService::~SituareService()
  55 {
  56     qDebug() << __PRETTY_FUNCTION__;
  57
  58     if(m_user) {
  59         delete m_user;
  60         m_user = 0;
  61     }
  62
  63     qDeleteAll(m_friendsList.begin(), m_friendsList.end());
  64     m_friendsList.clear();
  65 }
  66
  67 void SituareService::fetchLocations()
  68 {
  69     qDebug() << __PRETTY_FUNCTION__;
  70
  71     QString cookie = formCookie(API_KEY, m_credentials.expires(), m_credentials.userID(),
  72                                 m_credentials.sessionKey(), m_credentials.sessionSecret(),
  73                                 m_credentials.sig(), EN_LOCALE);
  74
  75     QUrl url = formUrl(SITUARE_URL, GET_LOCATIONS);
  76     sendRequest(url, COOKIE, cookie);
  77 }
  78
  79 void SituareService::reverseGeo(const GeoCoordinate &coordinates)
  80 {
  81     qDebug() << __PRETTY_FUNCTION__;
  82
  83     QString cookie = formCookie(API_KEY, m_credentials.expires(),m_credentials.userID(),
  84                                 m_credentials.sessionKey(), m_credentials.sessionSecret(),
  85                                 m_credentials.sig(), EN_LOCALE);
  86
  87     QString urlParameters = formUrlParameters(coordinates);
  88     urlParameters.append(JSON_FORMAT);
  89     QUrl url = formUrl(SITUARE_URL, REVERSE_GEO, urlParameters);
  90
  91     sendRequest(url, COOKIE, cookie);
  92 }
  93
  94 void SituareService::updateLocation(const GeoCoordinate &coordinates, const QString &status,
  95                                     const bool &publish)
  96 {
  97     qDebug() << __PRETTY_FUNCTION__;
  98
  99     QString urlParameters = formUrlParameters(coordinates, status, publish);
 100     QUrl url = formUrl(SITUARE_URL, UPDATE_LOCATION, urlParameters);
 101
 102     QString cookie = formCookie(API_KEY, m_credentials.expires(), m_credentials.userID(),
 103                                 m_credentials.sessionKey(), m_credentials.sessionSecret(),
 104                                 m_credentials.sig(), EN_LOCALE);
 105
 106     sendRequest(url, COOKIE, cookie);
 107 }
 108
 109 QString SituareService::formCookie(const QString &apiKeyValue, QString expiresValue,
 110                                    QString userValue, QString sessionKeyValue,
 111                                    QString sessionSecretValue, const QString &signatureValue,
 112                                    const QString &localeValue)
 113 {
 114     qDebug() << __PRETTY_FUNCTION__;
 115
 116     QString cookie;
 117     QString apiKey;
 118     QString user;
 119     QString expires;
 120     QString sessionKey;
 121     QString sessionSecret;
 122     QString locale;
 123     QString variable;
 124     QString signature = EQUAL_MARK;
 125     QStringList variableList;
 126
 127     signature.append(signatureValue);
 128     apiKey.append(apiKeyValue);
 129     apiKey.append(UNDERLINE_MARK);
 130
 131     user.append(USER);
 132     user.append(EQUAL_MARK);
 133     expires.append(EXPIRES);
 134     expires.append(EQUAL_MARK);
 135     sessionKey.append(SESSION_KEY);
 136     sessionKey.append(EQUAL_MARK);
 137     sessionSecret.append(SESSION_SECRET);
 138     sessionSecret.append(EQUAL_MARK);
 139     locale.append(LOCALE);
 140     locale.append(EQUAL_MARK);
 141     locale.append(localeValue);
 142
 143     variableList.append(expires.append(expiresValue.append(BREAK_MARK)));
 144     variableList.append(sessionKey.append(sessionKeyValue.append(BREAK_MARK)));
 145     variableList.append(user.append(userValue).append(BREAK_MARK));
 146     variableList.append(sessionSecret.append(sessionSecretValue.append(BREAK_MARK)));
 147
 148     cookie.append(BREAK_MARK);
 149
 150     foreach(variable, variableList) {
 151         cookie.append(apiKey);
 152         cookie.append(variable);
 153     }
 154     apiKey.remove(UNDERLINE_MARK);
 155     cookie.append(apiKey);
 156     cookie.append(signature);
 157     cookie.append(BREAK_MARK);
 158     cookie.append(locale);
 159
 160     qDebug() << cookie;
 161
 162     return cookie;
 163 }
 164
 165 QUrl SituareService::formUrl(const QString &baseUrl, const QString &phpScript,
 166                              QString urlParameters)
 167 {
 168     qDebug() << __PRETTY_FUNCTION__;
 169     QString urlString;
 170
 171     urlString.append(baseUrl);
 172     urlString.append(phpScript);
 173     if(!urlParameters.isEmpty())
 174         urlString.append(urlParameters);
 175
 176     QUrl url = QUrl(urlString);
 177
 178     qDebug() << url;
 179
 180     return url;
 181 }
 182
 183 QString SituareService::formUrlParameters(const GeoCoordinate &coordinates, QString status,
 184                                           bool publish)
 185 {
 186     qDebug() << __PRETTY_FUNCTION__;
 187
 188     // one scene pixel is about 5.4e-6 degrees, the integer part is max three digits and one
 189     // additional digit is added for maximum precision
 190     const int COORDINATE_PRECISION = 10;
 191
 192     QString parameters;
 193
 194     parameters.append(QUESTION_MARK);
 195     parameters.append(LATITUDE);
 196     parameters.append(EQUAL_MARK);
 197     parameters.append(QString::number(coordinates.latitude(), 'f', COORDINATE_PRECISION));
 198     parameters.append(AMBERSAND_MARK);
 199     parameters.append(LONGTITUDE);
 200     parameters.append(EQUAL_MARK);
 201     parameters.append(QString::number(coordinates.longitude(), 'f', COORDINATE_PRECISION));
 202
 203     parameters.append(AMBERSAND_MARK);
 204     parameters.append(PUBLISH);
 205     parameters.append(EQUAL_MARK);
 206
 207     if(publish)
 208         parameters.append(PUBLISH_TRUE);
 209     else
 210         parameters.append(PUBLISH_FALSE);
 211
 212     if(!status.isEmpty()) {
 213         parameters.append(AMBERSAND_MARK);
 214         parameters.append(DATA);
 215         parameters.append(EQUAL_MARK);
 216         parameters.append(status);
 217     }
 218
 219     return parameters;
 220 }
 221
 222 void SituareService::sendRequest(const QUrl &url, const QString &cookieType, const QString &cookie)
 223 {
 224     qDebug() << __PRETTY_FUNCTION__;
 225
 226     QNetworkRequest request;
 227
 228     request.setUrl(url);
 229     request.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
 230     request.setRawHeader(cookieType.toAscii(), cookie.toUtf8());
 231
 232     QNetworkReply *reply = m_networkManager->get(request, true);
 233
 234     m_currentRequests.append(reply);
 235 }
 236
 237 void SituareService::requestFinished(QNetworkReply *reply)
 238 {
 239     qDebug() << __PRETTY_FUNCTION__;
 240
 241     //Reply from situare
 242     if (m_currentRequests.contains(reply)) {
 243
 244         qDebug() << "BytesAvailable: " << reply->bytesAvailable();
 245
 246         if (reply->error()) {
 247             emit error(ErrorContext::NETWORK, reply->error());
 248         } else {
 249             QByteArray replyArray = reply->readAll();
 250             qDebug() << "Reply from: " << reply->url() << "reply " << replyArray;
 251
 252             if(replyArray == ERROR_LAT.toAscii()) {
 253                 qDebug() << "Error: " << ERROR_LAT;
 254                 emit error(ErrorContext::SITUARE, SituareError::UPDATE_FAILED);
 255             } else if(replyArray == ERROR_LON.toAscii()) {
 256                 qDebug() << "Error: " << ERROR_LON;
 257                 emit error(ErrorContext::SITUARE, SituareError::UPDATE_FAILED);
 258             } else if(replyArray.contains(ERROR_SESSION.toAscii())) {
 259                 qDebug() << "Error: " << ERROR_SESSION;
 260                 emit error(ErrorContext::SITUARE, SituareError::SESSION_EXPIRED);
 261             } else if(replyArray.startsWith(OPENING_BRACE_MARK.toAscii())) {
 262                 qDebug() << "JSON string";
 263                 parseUserData(replyArray);
 264             } else if(replyArray.isEmpty()) {
 265                 if(reply->url().toString().contains(UPDATE_LOCATION.toAscii())) {
 266                     emit updateWasSuccessful();
 267                 } else {
 268                     // session credentials are invalid
 269                     emit error(ErrorContext::SITUARE, SituareError::SESSION_EXPIRED);
 270                 }
 271             } else {
 272                 // unknown reply
 273                 emit error(ErrorContext::SITUARE, SituareError::ERROR_GENERAL);
 274             }
 275         }
 276         m_currentRequests.removeAll(reply);
 277         reply->deleteLater();
 278     }
 279 }
 280
 281 void SituareService::credentialsReady(const FacebookCredentials &credentials)
 282 {
 283     qDebug() << __PRETTY_FUNCTION__;
 284
 285     m_credentials = credentials;
 286 }
 287
 288 void SituareService::parseUserData(const QByteArray &jsonReply)
 289 {
 290     qDebug() << __PRETTY_FUNCTION__;
 291
 292     m_defaultImage = false;
 293
 294     QJson::Parser parser;
 295     bool ok;
 296
 297     QVariantMap result = parser.parse (jsonReply, &ok).toMap();
 298     if (!ok) {
 299         emit error(ErrorContext::SITUARE, SituareError::INVALID_JSON);
 300         return;
 301     } else {
 302
 303         if(result.contains("ErrorCode")) {
 304             QVariant errorVariant = result.value("ErrorCode");
 305             emit error(ErrorContext::SITUARE, errorVariant.toInt());
 306             return;
 307         } else if(result.contains("user")) {
 308
 309             QVariant userVariant = result.value("user");
 310             QMap<QString, QVariant> userMap = userVariant.toMap();
 311
 312             GeoCoordinate coordinates(userMap["latitude"].toReal(), userMap["longitude"].toReal());
 313
 314             QUrl imageUrl = userMap[NORMAL_SIZE_PROFILE_IMAGE].toUrl();
 315
 316             if(imageUrl.isEmpty()) {
 317                 // user doesn't have profile image, so we need to get him a silhouette image
 318                 m_defaultImage = true;
 319             }
 320
 321             QString address = userMap["address"].toString();
 322             if(address.isEmpty()) {
 323                 QStringList location;
 324                 location.append(QString::number(coordinates.latitude()));
 325                 location.append(QString::number(coordinates.longitude()));
 326                 address = location.join(", ");
 327             }
 328
 329             User user = User(address, coordinates, userMap["name"].toString(),
 330                           userMap["note"].toString(), imageUrl, userMap["timestamp"].toString(),
 331                           true, userMap["uid"].toString());
 332
 333             QList<User> tmpFriendsList;
 334
 335             foreach (QVariant friendsVariant, result["friends"].toList()) {
 336               QMap<QString, QVariant> friendMap = friendsVariant.toMap();
 337               QVariant distance = friendMap["distance"];
 338               QMap<QString, QVariant> distanceMap = distance.toMap();
 339
 340               GeoCoordinate coordinates(friendMap["latitude"].toReal(),friendMap["longitude"].toReal());
 341
 342               QUrl imageUrl = friendMap["profile_pic"].toUrl();
 343
 344               if(imageUrl.isEmpty()) {
 345                   // friend doesn't have profile image, so we need to get him a silhouette image
 346                   m_defaultImage = true;
 347               }
 348
 349               QString address = friendMap["address"].toString();
 350               if(address.isEmpty()) {
 351                   QStringList location;
 352                   location.append(QString::number(coordinates.latitude()));
 353                   location.append(QString::number(coordinates.longitude()));
 354                   address = location.join(", ");
 355               }
 356
 357               User buddy = User(address, coordinates, friendMap["name"].toString(),
 358                                friendMap["note"].toString(), imageUrl,
 359                                friendMap["timestamp"].toString(),
 360                                false, friendMap["uid"].toString(), distanceMap["units"].toString(),
 361                                distanceMap["value"].toDouble());
 362
 363               tmpFriendsList.append(buddy);
 364             }
 365
 366             QList<QUrl> imageUrlList; // url list for images
 367
 368             // set unchanged profile images or add new images to imageUrlList for downloading
 369             if(m_user) {
 370                 if(m_user->profileImageUrl() != user.profileImageUrl()) {
 371                     if(!user.profileImageUrl().isEmpty())
 372                         imageUrlList.append(user.profileImageUrl());
 373                 } else {
 374                     user.setProfileImage(m_user->profileImage());
 375                 }
 376             } else {
 377                 if(!user.profileImageUrl().isEmpty())
 378                     imageUrlList.append(user.profileImageUrl());
 379             }
 380
 381             // clear old user object
 382             if(m_user) {
 383                 delete m_user;
 384                 m_user = 0;
 385             }
 386
 387             // create new user object from temporary user object
 388             m_user = new User(user);
 389
 390             // set unchanged profile images or add new images to imageUrlList for downloading
 391             if(!m_friendsList.isEmpty()) {
 392                 foreach(User tmpBuddy, tmpFriendsList) {
 393                     if(!tmpBuddy.profileImageUrl().isEmpty()) {
 394                         bool found = false;
 395                         foreach(User *buddy, m_friendsList) {
 396                             if(tmpBuddy.profileImageUrl() == buddy->profileImageUrl()) {
 397                                 tmpBuddy.setProfileImage(buddy->profileImage());
 398                                 found = true;
 399                                 break;
 400                             }
 401                         }
 402                         if(!found && !tmpBuddy.profileImageUrl().isEmpty())
 403                             imageUrlList.append(tmpBuddy.profileImageUrl());
 404                     }
 405                 }
 406             } else {
 407                 foreach(User buddy, tmpFriendsList) {
 408                     if(!buddy.profileImageUrl().isEmpty())
 409                         imageUrlList.append(buddy.profileImageUrl());
 410                 }
 411             }
 412
 413             // clear old friendlist
 414             qDeleteAll(m_friendsList.begin(), m_friendsList.end());
 415             m_friendsList.clear();
 416
 417             // populate new friendlist with temporary friendlist's data
 418             foreach(User tmpFriendItem, tmpFriendsList) {
 419                 User *friendItem = new User(tmpFriendItem);
 420                 m_friendsList.append(friendItem);
 421             }
 422             tmpFriendsList.clear();
 423
 424             emit userDataChanged(m_user, m_friendsList);
 425
 426             // set silhouette image to imageUrlList for downloading
 427             if(m_defaultImage)
 428                 imageUrlList.append(QUrl(SILHOUETTE_URL));
 429
 430             addProfileImages(imageUrlList);
 431             imageUrlList.clear();
 432         } else {
 433             QVariant address = result.value("address");
 434             if(!address.toString().isEmpty()) {
 435                 emit reverseGeoReady(address.toString());
 436             } else {
 437                 QStringList coordinates;
 438                 coordinates.append(result.value("lat").toString());
 439                 coordinates.append(result.value("lon").toString());
 440
 441                 emit error(ErrorContext::SITUARE, SituareError::ADDRESS_RETRIEVAL_FAILED);
 442                 emit reverseGeoReady(coordinates.join(", "));
 443             }
 444         }
 445     }
 446 }
 447
 448 void SituareService::imageReceived(const QUrl &url, const QPixmap &image)
 449 {
 450     qDebug() << __PRETTY_FUNCTION__;
 451     qDebug() << "Image URL: " << url << " size :" << image.size();
 452
 453     // assign facebook silhouette image to all who doesn't have a profile image
 454     if(url == QUrl(SILHOUETTE_URL)) {
 455         if(m_user->profileImageUrl().isEmpty()) {
 456             m_user->setProfileImage(AvatarImage::create(image, AvatarImage::Large));
 457             emit imageReady(m_user);
 458         }
 459         foreach(User *friendItem, m_friendsList) {
 460             if(friendItem->profileImageUrl().isEmpty()) {
 461                 friendItem->setProfileImage(AvatarImage::create(image, AvatarImage::Small));
 462                 emit imageReady(friendItem);
 463             }
 464         }
 465     }
 466
 467     if (m_user->profileImageUrl() == url) {
 468         m_user->setProfileImage(AvatarImage::create(image, AvatarImage::Large));
 469         emit imageReady(m_user);
 470     }
 471
 472     foreach(User *friendItem, m_friendsList) {
 473         if(friendItem->profileImageUrl() == url) {
 474             friendItem->setProfileImage(AvatarImage::create(image, AvatarImage::Small));
 475             emit imageReady(friendItem);
 476         }
 477     }
 478 }
 479
 480 void SituareService::addProfileImages(const QList<QUrl> &imageUrlList)
 481 {
 482     qDebug() << __PRETTY_FUNCTION__;
 483
 484     foreach(QUrl url, imageUrlList) {
 485         emit fetchImage(url);
 486     }
 487 }
 488
 489 void SituareService::clearUserData()
 490 {
 491     qDebug() << __PRETTY_FUNCTION__;
 492
 493     qDeleteAll(m_friendsList.begin(), m_friendsList.end());
 494     m_friendsList.clear();
 495
 496     if(m_user) {
 497         delete m_user;
 498         m_user = 0;
 499     }
 500     emit userDataChanged(m_user, m_friendsList);
 501 }