vcs.maemo.org Git - ubi/blob - utils.cpp

   1 #include "utils.h"
   2 #include <QDebug>
   3
   4 Utils::Utils(QmlApplicationViewer *viewer, QSettings *settings, QObject *parent) :
   5     QObject(parent)
   6 {
   7     _viewer = viewer;
   8     _settings = settings;
   9     _clipboard = QApplication::clipboard();
  10
  11     _nam = new QNetworkAccessManager(this);
  12     isFinished = true;
  13 }
  14
  15 void Utils::minimizeWindow()
  16 {
  17 #if defined(Q_WS_MAEMO_5)
  18     // This is needed for Maemo5 to recognize minimization
  19     QDBusConnection connection = QDBusConnection::sessionBus();
  20     QDBusMessage message = QDBusMessage::createSignal(
  21                 "/","com.nokia.hildon_desktop","exit_app_view");
  22     connection.send(message);
  23 #else
  24     _viewer->setWindowState(Qt::WindowMinimized);
  25 #endif
  26 }
  27
  28 void Utils::setOrientation(const QString &orientation)
  29 {
  30     if(orientation=="auto")
  31         _viewer->setOrientation(QmlApplicationViewer::ScreenOrientationAuto);
  32     if(orientation=="landscape")
  33         _viewer->setOrientation(QmlApplicationViewer::ScreenOrientationLockLandscape);
  34     if(orientation=="portrait")
  35         _viewer->setOrientation(QmlApplicationViewer::ScreenOrientationLockPortrait);
  36 }
  37
  38 bool Utils::isAuthorized()
  39 {
  40     QString ck = customerKey();
  41     QString cs = customerSecret();
  42     QString t = token();
  43     QString ts = tokenSecret();
  44
  45     if(ck!="" && cs!="" && t!="" && ts!="")
  46         return true;
  47     else
  48         return false;
  49 }
  50
  51 void Utils::resetAuthorization()
  52 {
  53     setCustomerKey("");
  54     setCustomerSecret("");
  55     setToken("");
  56     setTokenSecret("");
  57     setName("");
  58 }
  59
  60 QString Utils::name()
  61 {
  62     return _settings->value("name").toString();
  63 }
  64
  65 void Utils::setName(const QString &name)
  66 {
  67     _settings->setValue("name",name);
  68 }
  69
  70 QString Utils::locale()
  71 {
  72     return _settings->value("locale").toString();
  73 }
  74
  75 void Utils::setLocale(const QString &locale)
  76 {
  77     _settings->setValue("locale",locale);
  78 }
  79
  80 QString Utils::customerKey()
  81 {
  82     return _settings->value("customer_key").toString();
  83 }
  84
  85 void Utils::setCustomerKey(const QString &ckey)
  86 {
  87     _settings->setValue("customer_key",ckey);
  88 }
  89
  90 QString Utils::customerSecret()
  91 {
  92     return _settings->value("customer_secret").toString();
  93 }
  94
  95 void Utils::setCustomerSecret(const QString &csecret)
  96 {
  97     _settings->setValue("customer_secret",csecret);
  98 }
  99
 100 QString Utils::token()
 101 {
 102     return _settings->value("token").toString();
 103 }
 104
 105 void Utils::setToken(const QString &token)
 106 {
 107     _settings->setValue("token",token);
 108 }
 109
 110 QString Utils::tokenSecret()
 111 {
 112     return _settings->value("token_secret").toString();
 113 }
 114
 115 /*QString Utils::backgroundColor()
 116 {
 117     return _settings->value("background_color").toString();
 118 }*/
 119
 120 void Utils::setTokenSecret(const QString &tsecret)
 121 {
 122     _settings->setValue("token_secret",tsecret);
 123 }
 124
 125 QString Utils::lastFolder()
 126 {
 127     return _settings->value("last_folder").toString();
 128 }
 129
 130 void Utils::setLastFolder(const QString &folder)
 131 {
 132     _settings->setValue("last_folder",folder);
 133 }
 134
 135 /*void Utils::setBackgroundColor(const QString &color)
 136 {
 137     _settings->setValue("background_color",color);
 138 }*/
 139
 140
 141 void Utils::downloadFile(const QString &folder, const QString &filename,
 142                          const QString &url, int size, const QString &auth)
 143 {
 144     RequestData data;
 145     data.isDownload = true;
 146     data.folder = folder;
 147     data.filename = filename;
 148     data.url = url;
 149     data.auth = auth;
 150     data.size = size;
 151     quee.append(data);
 152
 153     emit downloadAdded(filename);
 154
 155     if(isFinished){
 156         start();
 157     }
 158 }
 159
 160 void Utils::start()
 161 {
 162     if(quee.isEmpty()) {
 163         //qDebug() << "quee.isEmpty";
 164         return;
 165     }
 166
 167     RequestData data = quee.takeFirst();
 168
 169     QUrl url(data.url);
 170     QNetworkRequest req(url);
 171     req.setRawHeader("Authorization", data.auth.toAscii());
 172
 173     if(data.isDownload)
 174     {
 175         QNetworkReply* reply = _nam->get(req);
 176
 177         connect(reply,SIGNAL(finished()),this,SLOT(downloadFinished()));
 178         connect(reply,SIGNAL(downloadProgress(qint64,qint64)),this,SLOT(downloadProgress(qint64,qint64)));
 179         connect(reply,SIGNAL(error(QNetworkReply::NetworkError)),this,SLOT(error(QNetworkReply::NetworkError)));
 180
 181         cur_reply = reply;
 182         cur_folder = data.folder;
 183         cur_filename = data.filename;
 184         cur_size = data.size;
 185
 186         isFinished = false;
 187
 188         emit downloadStarted(data.filename);
 189
 190         //qDebug() << "startDownload, filename: " << cur_filename;
 191     }
 192     else
 193     {
 194         QString filepath = data.folder + "/" + data.filename;
 195         //qDebug() << "filapath: " << filepath;
 196         cur_file = new QFile(filepath);
 197         if(cur_file->open(QIODevice::ReadOnly)) {
 198             QNetworkReply* reply = _nam->put(req,cur_file);
 199
 200             connect(reply,SIGNAL(finished()),this,SLOT(uploadFinished()));
 201             connect(reply,SIGNAL(uploadProgress(qint64,qint64)),this,SLOT(uploadProgress(qint64,qint64)));
 202             connect(reply,SIGNAL(error(QNetworkReply::NetworkError)),this,SLOT(error(QNetworkReply::NetworkError)));
 203
 204             cur_reply = reply;
 205             cur_folder = data.folder;
 206             cur_filename = data.filename;
 207             cur_size = cur_file->size();
 208
 209             isFinished = false;
 210
 211             emit uploadStarted(data.filename);
 212
 213             //qDebug() << "size:" << cur_file->size();
 214
 215         } else {
 216             qDebug() << "error: file not open!";
 217         }
 218
 219     }
 220 }
 221
 222 void Utils::downloadFinished()
 223 {
 224     //qDebug() << "downloadFinished";
 225     isFinished = true;
 226     if (cur_reply->error() == QNetworkReply::NoError)
 227     {
 228         int httpStatus = cur_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 229         //qDebug() << "status: " << httpStatus;
 230
 231         if(httpStatus<300) {
 232             QByteArray bytes = cur_reply->readAll();
 233             QString filepath = cur_folder + "/" + cur_filename;
 234             QFile file(filepath);
 235             file.open(QIODevice::WriteOnly);
 236             int len = bytes.length();
 237             QDataStream out(&file);
 238             out.writeRawData(bytes.constData(),len);
 239             file.close();
 240             emit fileDownloaded(cur_filename);
 241         } else {
 242             qDebug() << "download error";
 243             emit downloadError(cur_filename);
 244         }
 245     }
 246     else if (cur_reply->error() == QNetworkReply::OperationCanceledError)
 247     {
 248         emit operationCanceled(cur_filename);
 249     }
 250     else
 251     {
 252         //qDebug() << "download error";
 253         emit downloadError(cur_filename);
 254     }
 255
 256     cur_reply->close();
 257     cur_reply->deleteLater();
 258
 259     start();
 260 }
 261
 262 void Utils::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
 263 {
 264     //qDebug() << "progres: " << 100*bytesReceived/cur_size << "%";
 265
 266     float progress = (float)bytesReceived/cur_size;
 267
 268     emit fileDownloadProgress(cur_filename,progress);
 269 }
 270
 271 void Utils::error(QNetworkReply::NetworkError code)
 272 {
 273     qDebug() << "error: " << code;
 274 }
 275
 276 void Utils::uploadFile(const QString &folder, const QString &filename,
 277                        const QString &url, const QString &auth)
 278 {
 279     //qDebug() << "uploadFile";
 280
 281     RequestData data;
 282     data.isDownload = false;
 283     data.folder = folder;
 284     data.filename = filename;
 285     data.url = url;
 286     data.auth = auth;
 287     quee.append(data);
 288
 289     emit uploadAdded(filename);
 290
 291     //qDebug() << "utils.cpp:uploadFile url=" << url;
 292
 293     if(isFinished){
 294         start();
 295     }
 296 }
 297
 298 void Utils::uploadProgress(qint64 bytesSent, qint64 bytesTotal)
 299 {
 300     //qDebug() << "progres: " << 100*bytesSent/cur_size << "%";
 301     //qDebug() << "progres: " << 100*bytesSent/bytesTotal << "%";
 302
 303     float progress = (float)bytesSent/cur_size;
 304     emit fileUploadProgress(cur_filename,progress);
 305 }
 306
 307 void Utils::uploadFinished()
 308 {
 309     //qDebug() << "uploadFinished";
 310     isFinished = true;
 311     if (cur_reply->error() == QNetworkReply::NoError)
 312     {
 313         emit fileUploaded(cur_filename);
 314     }
 315     else if (cur_reply->error() == QNetworkReply::OperationCanceledError)
 316     {
 317         emit operationCanceled(cur_filename);
 318     }
 319     else
 320     {
 321         int httpStatus = cur_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 322
 323         //QString httpStatusMessage = cur_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
 324         //QByteArray bytes = cur_reply->readAll();
 325         //qDebug() << "status: " << httpStatus << " " << httpStatusMessage;
 326         //qDebug() << "bytes: " << bytes;
 327
 328         if(httpStatus==503)
 329         {
 330             emit fileUploaded(cur_filename);
 331         } else {
 332             //qDebug() << "upload error: " << httpStatus << " " << cur_reply->error() << " " << cur_reply->errorString();
 333             emit uploadError(cur_filename);
 334         }
 335     }
 336
 337     cur_file->close();
 338     delete cur_file;
 339     cur_reply->close();
 340     cur_reply->deleteLater();
 341
 342     start();
 343 }
 344
 345 bool Utils::emptyQuee()
 346 {
 347     return isFinished && quee.length()==0;
 348 }
 349
 350 void Utils::test()
 351 {
 352     QMessageBox msgBox;
 353     msgBox.setText("Test!");
 354     msgBox.exec();
 355 }
 356
 357 void Utils::deleteFile(const QString &url, const QString &auth)
 358 {
 359     //qDebug() << "Utils::deleteFile";
 360
 361     QUrl _url(url);
 362     QNetworkRequest req(_url);
 363
 364     /*qDebug() << "url1=" << url;
 365     qDebug() << "url2=" << req.url().toString();
 366     qDebug() << "url3=" << req.url().path();*/
 367
 368     //qDebug() << "auth: " << auth;
 369     req.setRawHeader("Authorization", auth.toAscii());
 370
 371     //qDebug() << "utils.cpp:uploadFile _nam=" << _nam->;
 372
 373     /*QList<QByteArray> l = req.rawHeaderList();
 374     QList<QByteArray>::iterator i;
 375     for(i=l.begin(); i!=l.end(); ++i)
 376         qDebug() << "header=" << *i;
 377         */
 378
 379     temp_reply = _nam->deleteResource(req);
 380     connect(temp_reply,SIGNAL(finished()),this,SLOT(deleteFinished()));
 381     connect(temp_reply,SIGNAL(error(QNetworkReply::NetworkError)),this,SLOT(error(QNetworkReply::NetworkError)));
 382 }
 383
 384 void Utils::deleteFinished()
 385 {
 386     //qDebug() << "Utils::deleteFinished";
 387
 388     int httpStatus = temp_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 389     QString httpStatusMessage = temp_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
 390     QByteArray bytes = temp_reply->readAll();
 391
 392     //qDebug() << "status: " << httpStatus << " " << httpStatusMessage;
 393     //qDebug() << "bytes: " << bytes;
 394
 395     if (temp_reply->error() == QNetworkReply::NoError)
 396     {
 397         emit fileDeleted();
 398     }
 399     else
 400     {
 401         emit operationError(httpStatus);
 402     }
 403
 404     temp_reply->close();
 405     temp_reply->deleteLater();
 406 }
 407
 408 void Utils::setClipboardText(const QString &text)
 409 {
 410     _clipboard->setText(text, QClipboard::Clipboard);
 411     _clipboard->setText(text, QClipboard::Selection);
 412 }
 413
 414 bool  Utils::isMaemo()
 415 {
 416 #if defined(Q_WS_MAEMO_5)
 417     return true;
 418 #endif
 419     return false;
 420 }
 421
 422 void Utils::cancelFile(const QString & filename)
 423 {
 424     //qDebug() << "Utils::cancelFile";
 425     if(!isFinished && cur_filename==filename)
 426     {
 427         cur_reply->abort();
 428     }
 429     else
 430     {
 431         int l = quee.size();
 432         for(int i=0;i<l;++i) {
 433             RequestData data = quee.at(i);
 434             //qDebug() << data.filename;
 435             if(data.filename==filename) {
 436                 quee.removeAt(i);
 437                 emit fileRemovedFromQuee(filename);
 438                 return;
 439             }
 440         }
 441     }
 442 }