git.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     //qDebug() << "Authorization: " << data.auth;
 172     //qDebug() << "Url: " << url.toEncoded();
 173     req.setRawHeader("Authorization", data.auth.toAscii());
 174
 175     if(data.isDownload)
 176     {
 177         QNetworkReply* reply = _nam->get(req);
 178
 179         connect(reply,SIGNAL(finished()),this,SLOT(downloadFinished()));
 180         connect(reply,SIGNAL(downloadProgress(qint64,qint64)),this,SLOT(downloadProgress(qint64,qint64)));
 181         connect(reply,SIGNAL(error(QNetworkReply::NetworkError)),this,SLOT(error(QNetworkReply::NetworkError)));
 182
 183         cur_reply = reply;
 184         cur_folder = data.folder;
 185         cur_filename = data.filename;
 186         cur_size = data.size;
 187
 188         isFinished = false;
 189
 190         emit downloadStarted(data.filename);
 191
 192         //qDebug() << "startDownload, filename: " << cur_filename;
 193     }
 194     else
 195     {
 196         QString filepath = data.folder + "/" + data.filename;
 197         //qDebug() << "filapath: " << filepath;
 198         cur_file = new QFile(filepath);
 199         if(cur_file->open(QIODevice::ReadOnly)) {
 200             QNetworkReply* reply = _nam->put(req,cur_file);
 201
 202             connect(reply,SIGNAL(finished()),this,SLOT(uploadFinished()));
 203             connect(reply,SIGNAL(uploadProgress(qint64,qint64)),this,SLOT(uploadProgress(qint64,qint64)));
 204             connect(reply,SIGNAL(error(QNetworkReply::NetworkError)),this,SLOT(error(QNetworkReply::NetworkError)));
 205
 206             cur_reply = reply;
 207             cur_folder = data.folder;
 208             cur_filename = data.filename;
 209             cur_size = cur_file->size();
 210
 211             isFinished = false;
 212
 213             emit uploadStarted(data.filename);
 214
 215             //qDebug() << "size:" << cur_file->size();
 216
 217         } else {
 218             qDebug() << "error: file not open!";
 219         }
 220
 221     }
 222 }
 223
 224 void Utils::downloadFinished()
 225 {
 226     //qDebug() << "downloadFinished";
 227     isFinished = true;
 228     if (cur_reply->error() == QNetworkReply::NoError)
 229     {
 230         int httpStatus = cur_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 231         //qDebug() << "status: " << httpStatus;
 232
 233         if(httpStatus<300) {
 234             QByteArray bytes = cur_reply->readAll();
 235             QString filepath = cur_folder + "/" + cur_filename;
 236             QFile file(filepath);
 237             file.open(QIODevice::WriteOnly);
 238             int len = bytes.length();
 239             QDataStream out(&file);
 240             out.writeRawData(bytes.constData(),len);
 241             file.close();
 242             emit fileDownloaded(cur_filename);
 243         } else {
 244             qDebug() << "download error";
 245             emit downloadError(cur_filename);
 246         }
 247     }
 248     else if (cur_reply->error() == QNetworkReply::OperationCanceledError)
 249     {
 250         emit operationCanceled(cur_filename);
 251     }
 252     else
 253     {
 254         //qDebug() << "download error";
 255         emit downloadError(cur_filename);
 256     }
 257
 258     cur_reply->close();
 259     cur_reply->deleteLater();
 260
 261     start();
 262 }
 263
 264 void Utils::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
 265 {
 266     //qDebug() << "progres: " << 100*bytesReceived/cur_size << "%";
 267
 268     float progress = (float)bytesReceived/cur_size;
 269
 270     emit fileDownloadProgress(cur_filename,progress);
 271 }
 272
 273 void Utils::error(QNetworkReply::NetworkError code)
 274 {
 275     qDebug() << "error: " << code;
 276 }
 277
 278 void Utils::uploadFile(const QString &folder, const QString &filename,
 279                        const QString &url, const QString &auth)
 280 {
 281     //qDebug() << "uploadFile";
 282
 283     RequestData data;
 284     data.isDownload = false;
 285     data.folder = folder;
 286     data.filename = filename;
 287     data.url = url;
 288     data.auth = auth;
 289     quee.append(data);
 290
 291     emit uploadAdded(filename);
 292
 293     //qDebug() << "utils.cpp:uploadFile url=" << url;
 294
 295     if(isFinished){
 296         start();
 297     }
 298 }
 299
 300 void Utils::uploadProgress(qint64 bytesSent, qint64 bytesTotal)
 301 {
 302     //qDebug() << "progres: " << 100*bytesSent/cur_size << "%";
 303     //qDebug() << "progres: " << 100*bytesSent/bytesTotal << "%";
 304
 305     float progress = (float)bytesSent/cur_size;
 306     emit fileUploadProgress(cur_filename,progress);
 307 }
 308
 309 void Utils::uploadFinished()
 310 {
 311     //qDebug() << "uploadFinished";
 312     isFinished = true;
 313     if (cur_reply->error() == QNetworkReply::NoError)
 314     {
 315         emit fileUploaded(cur_filename);
 316     }
 317     else if (cur_reply->error() == QNetworkReply::OperationCanceledError)
 318     {
 319         emit operationCanceled(cur_filename);
 320     }
 321     else
 322     {
 323         int httpStatus = cur_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 324
 325         //QString httpStatusMessage = cur_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
 326         //QByteArray bytes = cur_reply->readAll();
 327         //qDebug() << "status: " << httpStatus << " " << httpStatusMessage;
 328         //qDebug() << "bytes: " << bytes;
 329
 330         if(httpStatus==503)
 331         {
 332             emit fileUploaded(cur_filename);
 333         } else {
 334             //qDebug() << "upload error: " << httpStatus << " " << cur_reply->error() << " " << cur_reply->errorString();
 335             emit uploadError(cur_filename);
 336         }
 337     }
 338
 339     cur_file->close();
 340     delete cur_file;
 341     cur_reply->close();
 342     cur_reply->deleteLater();
 343
 344     start();
 345 }
 346
 347 bool Utils::emptyQuee()
 348 {
 349     return isFinished && quee.length()==0;
 350 }
 351
 352 void Utils::test()
 353 {
 354     QMessageBox msgBox;
 355     msgBox.setText("Test!");
 356     msgBox.exec();
 357 }
 358
 359 void Utils::deleteFile(const QString &url, const QString &auth)
 360 {
 361     //qDebug() << "Utils::deleteFile";
 362
 363     QUrl _url(url);
 364     QNetworkRequest req(_url);
 365
 366     /*qDebug() << "url1=" << url;
 367     qDebug() << "url2=" << req.url().toString();
 368     qDebug() << "url3=" << req.url().path();*/
 369
 370     //qDebug() << "auth: " << auth;
 371     req.setRawHeader("Authorization", auth.toAscii());
 372
 373     //qDebug() << "utils.cpp:uploadFile _nam=" << _nam->;
 374
 375     /*QList<QByteArray> l = req.rawHeaderList();
 376     QList<QByteArray>::iterator i;
 377     for(i=l.begin(); i!=l.end(); ++i)
 378         qDebug() << "header=" << *i;
 379         */
 380
 381     temp_reply = _nam->deleteResource(req);
 382     connect(temp_reply,SIGNAL(finished()),this,SLOT(deleteFinished()));
 383     connect(temp_reply,SIGNAL(error(QNetworkReply::NetworkError)),this,SLOT(error(QNetworkReply::NetworkError)));
 384 }
 385
 386 void Utils::deleteFinished()
 387 {
 388     //qDebug() << "Utils::deleteFinished";
 389
 390     int httpStatus = temp_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 391     QString httpStatusMessage = temp_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
 392     QByteArray bytes = temp_reply->readAll();
 393
 394     //qDebug() << "status: " << httpStatus << " " << httpStatusMessage;
 395     //qDebug() << "bytes: " << bytes;
 396
 397     if (temp_reply->error() == QNetworkReply::NoError)
 398     {
 399         emit fileDeleted();
 400     }
 401     else
 402     {
 403         emit operationError(httpStatus);
 404     }
 405
 406     temp_reply->close();
 407     temp_reply->deleteLater();
 408 }
 409
 410 void Utils::setClipboardText(const QString &text)
 411 {
 412     _clipboard->setText(text, QClipboard::Clipboard);
 413     _clipboard->setText(text, QClipboard::Selection);
 414 }
 415
 416 bool  Utils::isMaemo()
 417 {
 418 #if defined(Q_WS_MAEMO_5)
 419     return true;
 420 #endif
 421     return false;
 422 }
 423
 424 void Utils::cancelFile(const QString & filename)
 425 {
 426     //qDebug() << "Utils::cancelFile";
 427     if(!isFinished && cur_filename==filename)
 428     {
 429         cur_reply->abort();
 430     }
 431     else
 432     {
 433         int l = quee.size();
 434         for(int i=0;i<l;++i) {
 435             RequestData data = quee.at(i);
 436             //qDebug() << data.filename;
 437             if(data.filename==filename) {
 438                 quee.removeAt(i);
 439                 emit fileRemovedFromQuee(filename);
 440                 return;
 441             }
 442         }
 443     }
 444 }