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 <qjson/parser.h>
  23
  24 #include <QDebug>
  25 #include <QNetworkReply>
  26 #include <QPixmap>
  27 #include <QStringList>
  28 #include <QtAlgorithms>
  29 #include <QtGlobal>
  30
  31 #include "error.h"
  32 #include "network/networkaccessmanager.h"
  33 #include "situarecommon.h"
  34 #include "ui/avatarimage.h"
  35
  36 #include "situareservice.h"
  37
  38 SituareService::SituareService(QObject *parent)
  39         : QObject(parent),
  40         m_user(0)
  41 {
  42     qDebug() << __PRETTY_FUNCTION__;
  43
  44     m_networkManager = new NetworkAccessManager(this);
  45     connect(m_networkManager, SIGNAL(finished(QNetworkReply*)),
  46             this, SLOT(requestFinished(QNetworkReply*)), Qt::QueuedConnection);
  47
  48     m_imageFetcher = new ImageFetcher(new NetworkAccessManager(this), this);
  49     connect(this, SIGNAL(fetchImage(QUrl)),
  50             m_imageFetcher, SLOT(fetchImage(QUrl)));
  51     connect(m_imageFetcher, SIGNAL(imageReceived(QUrl,QPixmap)),
  52             this, SLOT(imageReceived(QUrl, QPixmap)));
  53     connect(m_imageFetcher, SIGNAL(error(int, int)),
  54             this, SIGNAL(error(int, int)));
  55 }
  56
  57 SituareService::~SituareService()
  58 {
  59     qDebug() << __PRETTY_FUNCTION__;
  60
  61     if(m_user) {
  62         delete m_user;
  63         m_user = 0;
  64     }
  65
  66     qDeleteAll(m_friendsList.begin(), m_friendsList.end());
  67     m_friendsList.clear();
  68 }
  69
  70 void SituareService::addProfileImages(const QList<QUrl> &imageUrlList)
  71 {
  72     qDebug() << __PRETTY_FUNCTION__;
  73
  74     foreach(QUrl url, imageUrlList) {
  75         emit fetchImage(url);
  76     }
  77 }
  78
  79 void SituareService::appendAccessToken(QString &requestUrl)
  80 {
  81     qWarning() << __PRETTY_FUNCTION__;
  82
  83     requestUrl.append(m_session);
  84 }
  85
  86 void SituareService::buildRequest(const QString &script, const QHash<QString, QString> &parameters)
  87 {
  88     qWarning() << __PRETTY_FUNCTION__;
  89
  90     const QString PARAMETER_KEY_API = "api";
  91     const QString PARAMETER_VALUE_API = "2.0";
  92
  93     QString url = SITUARE_URL;
  94     url.append(script);
  95     url.append("?");
  96
  97     // append default api version parameter if not yet specified
  98 //    if (!parameters.contains(PARAMETER_KEY_API))
  99 //        url.append(PARAMETER_KEY_API + "=" + PARAMETER_VALUE_API + "&");
 100
 101     // append parameters
 102     if (!parameters.isEmpty()) {
 103         QHash<QString, QString>::const_iterator i = parameters.constBegin();
 104         while (i != parameters.constEnd()) {
 105             url.append(i.key());
 106             url.append("=");
 107             url.append(i.value());
 108             url.append("&");
 109             i++;
 110         }
 111     }
 112
 113 //    qWarning() << __PRETTY_FUNCTION__ << "request url with parameters:" << url;
 114
 115     if (!m_session.isEmpty()) {
 116         appendAccessToken(url);
 117         sendRequest(url);
 118     } else {
 119         m_requestsWaitingAccessToken.append(url);
 120         ///< @todo emit login request
 121     }
 122 }
 123
 124 void SituareService::clearUserData()
 125 {
 126     qDebug() << __PRETTY_FUNCTION__;
 127
 128     qDeleteAll(m_friendsList.begin(), m_friendsList.end());
 129     m_friendsList.clear();
 130
 131     if(m_user) {
 132         delete m_user;
 133         m_user = 0;
 134     }
 135     emit userDataChanged(m_user, m_friendsList);
 136 }
 137
 138 QString SituareService::degreesToString(double degrees)
 139 {
 140     qDebug() << __PRETTY_FUNCTION__;
 141
 142     // one scene pixel is about 5.4e-6 degrees, the integer part is max three digits and one
 143     // additional digit is added for maximum precision
 144     const int PRECISION = 10;
 145
 146     return QString::number(degrees, 'f', PRECISION);
 147 }
 148
 149 void SituareService::fetchLocations()
 150 {
 151     qDebug() << __PRETTY_FUNCTION__;
 152
 153     QHash<QString, QString> parameters;
 154     parameters.insert("extra_user_data", NORMAL_SIZE_PROFILE_IMAGE);
 155
 156     buildRequest(GET_LOCATIONS, parameters);
 157 }
 158
 159 QString SituareService::formCookie(const QString &apiKeyValue, QString expiresValue,
 160                                    QString userValue, QString sessionKeyValue,
 161                                    QString sessionSecretValue, const QString &signatureValue,
 162                                    const QString &localeValue)
 163 {
 164     qDebug() << __PRETTY_FUNCTION__;
 165
 166     QString cookie;
 167     QString apiKey;
 168     QString user;
 169     QString expires;
 170     QString sessionKey;
 171     QString sessionSecret;
 172     QString locale;
 173     QString variable;
 174     QString signature = EQUAL_MARK;
 175     QStringList variableList;
 176
 177     signature.append(signatureValue);
 178     apiKey.append(apiKeyValue);
 179     apiKey.append(UNDERLINE_MARK);
 180
 181     user.append(USER);
 182     user.append(EQUAL_MARK);
 183     expires.append(EXPIRES);
 184     expires.append(EQUAL_MARK);
 185     sessionKey.append(SESSION_KEY);
 186     sessionKey.append(EQUAL_MARK);
 187     sessionSecret.append(SESSION_SECRET);
 188     sessionSecret.append(EQUAL_MARK);
 189     locale.append(LOCALE);
 190     locale.append(EQUAL_MARK);
 191     locale.append(localeValue);
 192
 193     variableList.append(expires.append(expiresValue.append(BREAK_MARK)));
 194     variableList.append(sessionKey.append(sessionKeyValue.append(BREAK_MARK)));
 195     variableList.append(user.append(userValue).append(BREAK_MARK));
 196     variableList.append(sessionSecret.append(sessionSecretValue.append(BREAK_MARK)));
 197
 198     cookie.append(BREAK_MARK);
 199
 200     foreach(variable, variableList) {
 201         cookie.append(apiKey);
 202         cookie.append(variable);
 203     }
 204     apiKey.remove(UNDERLINE_MARK);
 205     cookie.append(apiKey);
 206     cookie.append(signature);
 207     cookie.append(BREAK_MARK);
 208     cookie.append(locale);
 209
 210     qDebug() << cookie;
 211
 212     return cookie;
 213 }
 214
 215 QUrl SituareService::formUrl(const QString &baseUrl, const QString &phpScript,
 216                              QString urlParameters)
 217 {
 218     qDebug() << __PRETTY_FUNCTION__;
 219     QString urlString;
 220
 221     urlString.append(baseUrl);
 222     urlString.append(phpScript);
 223     if(!urlParameters.isEmpty())
 224         urlString.append(urlParameters);
 225
 226     QUrl url = QUrl(urlString);
 227
 228     qDebug() << url;
 229
 230     return url;
 231 }
 232
 233 QString SituareService::formUrlParameters(const GeoCoordinate &coordinates, QString status,
 234                                           bool publish)
 235 {
 236     qDebug() << __PRETTY_FUNCTION__;
 237
 238     QString parameters;
 239     parameters.append(QUESTION_MARK);
 240     parameters.append(LATITUDE);
 241     parameters.append(EQUAL_MARK);
 242     parameters.append(degreesToString(coordinates.latitude()));
 243     parameters.append(AMBERSAND_MARK);
 244     parameters.append(LONGTITUDE);
 245     parameters.append(EQUAL_MARK);
 246     parameters.append(degreesToString(coordinates.longitude()));
 247
 248     parameters.append(AMBERSAND_MARK);
 249     parameters.append(PUBLISH);
 250     parameters.append(EQUAL_MARK);
 251
 252     if(publish)
 253         parameters.append(PUBLISH_TRUE);
 254     else
 255         parameters.append(PUBLISH_FALSE);
 256
 257     if(!status.isEmpty()) {
 258         parameters.append(AMBERSAND_MARK);
 259         parameters.append(DATA);
 260         parameters.append(EQUAL_MARK);
 261         parameters.append(status);
 262     }
 263
 264     return parameters;
 265 }
 266
 267 void SituareService::imageReceived(const QUrl &url, const QPixmap &image)
 268 {
 269     qDebug() << __PRETTY_FUNCTION__;
 270     qDebug() << "Image URL: " << url << " size :" << image.size();
 271
 272     // assign facebook silhouette image to all who doesn't have a profile image
 273     if(url == QUrl(SILHOUETTE_URL)) {
 274         if(m_user->profileImageUrl().isEmpty()) {
 275             m_user->setProfileImage(AvatarImage::create(image, AvatarImage::Large));
 276             emit imageReady(m_user);
 277         }
 278         foreach(User *friendItem, m_friendsList) {
 279             if(friendItem->profileImageUrl().isEmpty()) {
 280                 friendItem->setProfileImage(AvatarImage::create(image, AvatarImage::Small));
 281                 emit imageReady(friendItem);
 282             }
 283         }
 284     }
 285
 286     if (m_user->profileImageUrl() == url) {
 287         m_user->setProfileImage(AvatarImage::create(image, AvatarImage::Large));
 288         emit imageReady(m_user);
 289     }
 290
 291     foreach(User *friendItem, m_friendsList) {
 292         if(friendItem->profileImageUrl() == url) {
 293             friendItem->setProfileImage(AvatarImage::create(image, AvatarImage::Small));
 294             emit imageReady(friendItem);
 295         }
 296     }
 297 }
 298
 299 void SituareService::parseUserData(const QByteArray &jsonReply)
 300 {
 301     qDebug() << __PRETTY_FUNCTION__;
 302
 303     m_defaultImage = false;
 304
 305     QJson::Parser parser;
 306     bool ok;
 307
 308     QVariantMap result = parser.parse (jsonReply, &ok).toMap();
 309     if (!ok) {
 310         emit error(ErrorContext::SITUARE, SituareError::INVALID_JSON);
 311         return;
 312     } else {
 313
 314         if(result.contains("ErrorCode")) {
 315             QVariant errorVariant = result.value("ErrorCode");
 316             emit error(ErrorContext::SITUARE, errorVariant.toInt());
 317             return;
 318         } else if(result.contains("user")) {
 319
 320             QVariant userVariant = result.value("user");
 321             QMap<QString, QVariant> userMap = userVariant.toMap();
 322
 323             GeoCoordinate coordinates(userMap["latitude"].toReal(), userMap["longitude"].toReal());
 324
 325             QUrl imageUrl = userMap[NORMAL_SIZE_PROFILE_IMAGE].toUrl();
 326
 327             if(imageUrl.isEmpty()) {
 328                 // user doesn't have profile image, so we need to get him a silhouette image
 329                 m_defaultImage = true;
 330             }
 331
 332             QString address = userMap["address"].toString();
 333             if(address.isEmpty()) {
 334                 QStringList location;
 335                 location.append(QString::number(coordinates.latitude()));
 336                 location.append(QString::number(coordinates.longitude()));
 337                 address = location.join(", ");
 338             }
 339
 340             User user = User(address, coordinates, userMap["name"].toString(),
 341                           userMap["note"].toString(), imageUrl, userMap["timestamp"].toString(),
 342                           true, userMap["uid"].toString());
 343
 344             QList<User> tmpFriendsList;
 345
 346             foreach (QVariant friendsVariant, result["friends"].toList()) {
 347               QMap<QString, QVariant> friendMap = friendsVariant.toMap();
 348               QVariant distance = friendMap["distance"];
 349               QMap<QString, QVariant> distanceMap = distance.toMap();
 350
 351               GeoCoordinate coordinates(friendMap["latitude"].toReal(),friendMap["longitude"].toReal());
 352
 353               QUrl imageUrl = friendMap["profile_pic"].toUrl();
 354
 355               if(imageUrl.isEmpty()) {
 356                   // friend doesn't have profile image, so we need to get him a silhouette image
 357                   m_defaultImage = true;
 358               }
 359
 360               QString address = friendMap["address"].toString();
 361               if(address.isEmpty()) {
 362                   QStringList location;
 363                   location.append(QString::number(coordinates.latitude()));
 364                   location.append(QString::number(coordinates.longitude()));
 365                   address = location.join(", ");
 366               }
 367
 368               User buddy = User(address, coordinates, friendMap["name"].toString(),
 369                                friendMap["note"].toString(), imageUrl,
 370                                friendMap["timestamp"].toString(),
 371                                false, friendMap["uid"].toString(), distanceMap["units"].toString(),
 372                                distanceMap["value"].toDouble());
 373
 374               tmpFriendsList.append(buddy);
 375             }
 376
 377             QList<QUrl> imageUrlList; // url list for images
 378
 379             // set unchanged profile images or add new images to imageUrlList for downloading
 380             if(m_user) {
 381                 if(m_user->profileImageUrl() != user.profileImageUrl()) {
 382                     if(!user.profileImageUrl().isEmpty())
 383                         imageUrlList.append(user.profileImageUrl());
 384                 } else {
 385                     user.setProfileImage(m_user->profileImage());
 386                 }
 387             } else {
 388                 if(!user.profileImageUrl().isEmpty())
 389                     imageUrlList.append(user.profileImageUrl());
 390             }
 391
 392             // clear old user object
 393             if(m_user) {
 394                 delete m_user;
 395                 m_user = 0;
 396             }
 397
 398             // create new user object from temporary user object
 399             m_user = new User(user);
 400
 401             // set unchanged profile images or add new images to imageUrlList for downloading
 402             if(!m_friendsList.isEmpty()) {
 403                 foreach(User tmpBuddy, tmpFriendsList) {
 404                     if(!tmpBuddy.profileImageUrl().isEmpty()) {
 405                         bool found = false;
 406                         foreach(User *buddy, m_friendsList) {
 407                             if(tmpBuddy.profileImageUrl() == buddy->profileImageUrl()) {
 408                                 tmpBuddy.setProfileImage(buddy->profileImage());
 409                                 found = true;
 410                                 break;
 411                             }
 412                         }
 413                         if(!found && !tmpBuddy.profileImageUrl().isEmpty())
 414                             imageUrlList.append(tmpBuddy.profileImageUrl());
 415                     }
 416                 }
 417             } else {
 418                 foreach(User buddy, tmpFriendsList) {
 419                     if(!buddy.profileImageUrl().isEmpty())
 420                         imageUrlList.append(buddy.profileImageUrl());
 421                 }
 422             }
 423
 424             // clear old friendlist
 425             qDeleteAll(m_friendsList.begin(), m_friendsList.end());
 426             m_friendsList.clear();
 427
 428             // populate new friendlist with temporary friendlist's data
 429             foreach(User tmpFriendItem, tmpFriendsList) {
 430                 User *friendItem = new User(tmpFriendItem);
 431                 m_friendsList.append(friendItem);
 432             }
 433             tmpFriendsList.clear();
 434
 435             emit userDataChanged(m_user, m_friendsList);
 436
 437             // set silhouette image to imageUrlList for downloading
 438             if(m_defaultImage)
 439                 imageUrlList.append(QUrl(SILHOUETTE_URL));
 440
 441             addProfileImages(imageUrlList);
 442             imageUrlList.clear();
 443         } else {
 444             QVariant address = result.value("address");
 445             if(!address.toString().isEmpty()) {
 446                 emit reverseGeoReady(address.toString());
 447             } else {
 448                 QStringList coordinates;
 449                 coordinates.append(result.value("lat").toString());
 450                 coordinates.append(result.value("lon").toString());
 451
 452                 emit error(ErrorContext::SITUARE, SituareError::ADDRESS_RETRIEVAL_FAILED);
 453                 emit reverseGeoReady(coordinates.join(", "));
 454             }
 455         }
 456     }
 457 }
 458
 459 void SituareService::requestFinished(QNetworkReply *reply)
 460 {
 461     qDebug() << __PRETTY_FUNCTION__;
 462
 463     //Reply from situare
 464     if (m_currentRequests.contains(reply)) {
 465
 466         qDebug() << "BytesAvailable: " << reply->bytesAvailable();
 467
 468         if (reply->error()) {
 469             emit error(ErrorContext::NETWORK, reply->error());
 470         } else {
 471             QByteArray replyArray = reply->readAll();
 472             qDebug() << "Reply from: " << reply->url() << "reply " << replyArray;
 473
 474             if(replyArray == ERROR_LAT.toAscii()) {
 475                 qDebug() << "Error: " << ERROR_LAT;
 476                 emit error(ErrorContext::SITUARE, SituareError::UPDATE_FAILED);
 477             } else if(replyArray == ERROR_LON.toAscii()) {
 478                 qDebug() << "Error: " << ERROR_LON;
 479                 emit error(ErrorContext::SITUARE, SituareError::UPDATE_FAILED);
 480             } else if(replyArray.contains(ERROR_SESSION.toAscii())) {
 481                 qDebug() << "Error: " << ERROR_SESSION;
 482                 emit error(ErrorContext::SITUARE, SituareError::SESSION_EXPIRED);
 483             } else if(replyArray.startsWith(OPENING_BRACE_MARK.toAscii())) {
 484                 qDebug() << "JSON string";
 485                 parseUserData(replyArray);
 486             } else if(replyArray.isEmpty()) {
 487                 if(reply->url().toString().contains(UPDATE_LOCATION.toAscii())) {
 488                     emit updateWasSuccessful();
 489                 } else {
 490                     // session credentials are invalid
 491                     emit error(ErrorContext::SITUARE, SituareError::SESSION_EXPIRED);
 492                 }
 493             } else {
 494                 // unknown reply
 495                 emit error(ErrorContext::SITUARE, SituareError::ERROR_GENERAL);
 496             }
 497         }
 498         m_currentRequests.removeAll(reply);
 499         reply->deleteLater();
 500     }
 501 }
 502
 503 void SituareService::reverseGeo(const GeoCoordinate &coordinates)
 504 {
 505     qDebug() << __PRETTY_FUNCTION__;
 506
 507     QHash<QString, QString> parameters;
 508     parameters.insert("lat", degreesToString(coordinates.latitude()));
 509     parameters.insert("lon", degreesToString(coordinates.longitude()));
 510     parameters.insert("format", "json");
 511
 512     buildRequest(REVERSE_GEO, parameters);
 513 }
 514
 515 void SituareService::sendRequest(const QUrl &url, const QString &cookieType, const QString &cookie)
 516 {
 517     qDebug() << __PRETTY_FUNCTION__;
 518
 519     QNetworkRequest request;
 520
 521     request.setUrl(url);
 522     request.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
 523     request.setRawHeader(cookieType.toAscii(), cookie.toUtf8());
 524
 525     QNetworkReply *reply = m_networkManager->get(request, true);
 526
 527     m_currentRequests.append(reply);
 528 }
 529
 530 void SituareService::sendRequest(const QString &requestUrl)
 531 {
 532     qWarning() << __PRETTY_FUNCTION__ << "requestUrl" << requestUrl;
 533
 534     // make and send the request
 535     QNetworkRequest request;
 536     request.setUrl(QUrl(requestUrl));
 537     request.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
 538     QNetworkReply *reply = m_networkManager->get(request, true);
 539     m_currentRequests.append(reply);
 540 }
 541
 542 void SituareService::updateSession(const QString &session)
 543 {
 544     qWarning() << __PRETTY_FUNCTION__;
 545
 546     m_session = session;
 547
 548     if (!m_session.isEmpty()) {
 549         foreach (QString request, m_requestsWaitingAccessToken) {
 550             appendAccessToken(request);
 551             sendRequest(request);
 552         }
 553     }
 554     else {
 555         clearUserData();
 556     }
 557
 558     m_requestsWaitingAccessToken.clear();
 559 }
 560
 561 void SituareService::updateLocation(const GeoCoordinate &coordinates, const QString &status,
 562                                     const bool &publish)
 563 {
 564     qDebug() << __PRETTY_FUNCTION__;
 565
 566     QHash<QString, QString> parameters;
 567     parameters.insert("lat", degreesToString(coordinates.latitude()));
 568     parameters.insert("lon", degreesToString(coordinates.longitude()));
 569     parameters.insert("publish", publish ? "true" : "false");
 570     parameters.insert("data", status); ///< @todo if !empty ???
 571
 572     buildRequest(UPDATE_LOCATION, parameters);
 573 }