kopete/libkopete/kopetetransfermanager.cpp

   1 /*
   2     kopetetransfermanager.cpp
   3
   4     Copyright (c) 2002-2003 by Nick Betcher           <nbetcher@kde.org>
   5     Copyright (c) 2002-2003 by Richard Smith          <kopete@metafoo.co.uk>
   6     Copyright (c) 2008      by Roman Jarosz           <kedgedev@centrum.cz>
   7
   8     Kopete    (c) 2002-2008 by the Kopete developers  <kopete-devel@kde.org>
   9
  10     *************************************************************************
  11     *                                                                       *
  12     * This library is free software; you can redistribute it and/or         *
  13     * modify it under the terms of the GNU Lesser General Public            *
  14     * License as published by the Free Software Foundation; either          *
  15     * version 2 of the License, or (at your option) any later version.      *
  16     *                                                                       *
  17     *************************************************************************
  18 */
  19
  20 #include <QtCore/QTimerEvent>
  21 #include <QtGui/QTextDocument>
  22
  23 #include <klocale.h>
  24 #include <kdebug.h>
  25 #include <kfiledialog.h>
  26 #include <kfileitem.h>
  27 #include <kmessagebox.h>
  28 #include <kio/jobuidelegate.h>
  29 #include <kuiserverjobtracker.h>
  30
  31 #include "kopetemetacontact.h"
  32 #include "kopetecontact.h"
  33 #include "kopetemessage.h"
  34 #include "kopetechatsession.h"
  35 #include "kopeteuiglobal.h"
  36
  37 #include "kopetetransfermanager.h"
  38
  39 /***************************
  40  *  Kopete::FileTransferInfo *
  41  ***************************/
  42
  43 Kopete::FileTransferInfo::FileTransferInfo()
  44 {
  45         mId = 0;
  46         mContact = 0;
  47         mSize = 0;
  48         mSaveToDirectory = false;
  49 }
  50
  51 Kopete::FileTransferInfo::FileTransferInfo(  Kopete::Contact *contact, const QStringList& files, const unsigned long size, const QString &recipient, KopeteTransferDirection di, const unsigned int id, QString internalId, const QPixmap &preview, bool saveToDirectory )
  52 {
  53         mContact = contact;
  54         mFiles = files;
  55         mId = id;
  56         mSize = size;
  57         mRecipient = recipient;
  58         m_intId= internalId;
  59         mDirection= di;
  60         mPreview = preview;
  61         mSaveToDirectory = saveToDirectory;
  62 }
  63
  64 /***************************
  65  *     Kopete::Transfer      *
  66  ***************************/
  67
  68 static const int TransferRateWindowLength = 10;
  69 static const int TransferRateTimerDelay = 1000;
  70
  71 class Kopete::Transfer::Private
  72 {
  73 public:
  74         Private( const Kopete::FileTransferInfo &ftInfo )
  75                 : info( ftInfo ), transferRateTimer( 0 )
  76         {
  77                 memset( transferRate, 0, sizeof(transferRate) );
  78         }
  79
  80         FileTransferInfo info;
  81         KUrl target;
  82
  83         //if ft has one file then localUrl is file otherwise it's directory
  84         KUrl localUrl;
  85
  86         int transferRate[TransferRateWindowLength];
  87         int transferRateTimer;
  88 };
  89
  90 Kopete::Transfer::Transfer( const Kopete::FileTransferInfo &kfti, const QString &localFile, bool showProgressInfo)
  91         : KIO::Job(), d( new Private(kfti) )
  92 {
  93         this->setUiDelegate(new KIO::JobUiDelegate());
  94         if(showProgressInfo)
  95                 KIO::getJobTracker()->registerJob(this);
  96
  97         KUrl targ; targ.setPath( localFile );
  98         d->localUrl = targ;
  99         init( targ, showProgressInfo );
 100 }
 101
 102 Kopete::Transfer::Transfer( const Kopete::FileTransferInfo &kfti, const Kopete::Contact *contact, bool showProgressInfo)
 103         : KIO::Job(), d( new Private(kfti) )
 104 {
 105         this->setUiDelegate(new KIO::JobUiDelegate());
 106         if(showProgressInfo)
 107                 KIO::getJobTracker()->registerJob(this);
 108
 109         // TODO: use mInfo.url().fileName() after move to protocol-aware filetransfers
 110         KUrl targ; targ.setPath( d->info.file() );
 111         init( displayURL( contact, targ.fileName() ), showProgressInfo );
 112 }
 113
 114 void Kopete::Transfer::init( const KUrl &target, bool showProgressInfo )
 115 {
 116         d->target = target;
 117         setTotalAmount( KJob::Files, d->info.files().count() );
 118         setTotalAmount( KJob::Bytes, d->info.size() );
 119
 120         if( showProgressInfo )
 121                 emitCopying( sourceURL(), destinationURL() );
 122
 123         connect( this, SIGNAL( result( KJob* ) ), SLOT( slotResultEmitted() ) );
 124
 125         ui()->setAutoErrorHandlingEnabled( true );
 126 }
 127
 128 Kopete::Transfer::~Transfer()
 129 {
 130         stopTransferRateTimer();
 131
 132         delete d;
 133 }
 134
 135 const Kopete::FileTransferInfo &Kopete::Transfer::info() const
 136 {
 137         return d->info;
 138 }
 139
 140 KUrl Kopete::Transfer::displayURL( const Kopete::Contact *contact, const QString &file )
 141 {
 142         KUrl url;
 143         url.setProtocol( QString::fromLatin1("kopete") );
 144
 145         QString host;
 146         if( !contact )
 147                 host = QString::fromLatin1("unknown origin");
 148         else if( contact->metaContact() )
 149                 host = contact->metaContact()->displayName();
 150         else
 151                 host = contact->contactId();
 152         url.setHost(host);
 153
 154         // url.setPath( contact->protocol()->displayName() );
 155
 156         url.setFileName( file );
 157         return url;
 158 }
 159
 160 void Kopete::Transfer::slotNextFile( const QString &sourceFile, const QString &destinationFile )
 161 {
 162         KUrl src;
 163         KUrl dest;
 164
 165         kDebug() << "source: " << sourceFile << " destination: " << destinationFile;
 166         if( d->info.direction() == Kopete::FileTransferInfo::Incoming )
 167         {
 168                 KUrl url( sourceFile );
 169                 src = displayURL( d->info.contact(), url.fileName() );
 170                 dest.setPath( destinationFile );
 171         }
 172         else
 173         {
 174                 src.setPath( sourceFile );
 175                 KUrl url( destinationFile );
 176                 dest = displayURL( d->info.contact(), url.fileName() );
 177         }
 178
 179         setProcessedAmount( KJob::Files, processedAmount(KJob::Files) + 1 );
 180         emit description(this, i18n("Copying"),
 181                          qMakePair(i18n("Source"), src.prettyUrl()),
 182                          qMakePair(i18n("Destination"), dest.prettyUrl()));
 183 }
 184
 185 // TODO: add possibility of network file transfers;
 186 //  call mInfo->url() not file()
 187 KUrl Kopete::Transfer::sourceURL()
 188 {
 189         if( d->info.direction() == Kopete::FileTransferInfo::Incoming )
 190                 return displayURL( d->info.contact(), d->info.file() );
 191         else
 192         {
 193                 KUrl url; url.setPath( d->info.file() );
 194                 return url;
 195         }
 196 }
 197
 198 KUrl Kopete::Transfer::destinationURL()
 199 {
 200         return d->target;
 201 }
 202
 203 void Kopete::Transfer::emitCopying(const KUrl &src, const KUrl &dest)
 204 {
 205     emit description(this, i18n("Copying"),
 206                      qMakePair(i18n("Source"), src.prettyUrl()),
 207                      qMakePair(i18n("Destination"), dest.prettyUrl()));
 208 }
 209
 210 void Kopete::Transfer::slotProcessed( unsigned int bytes )
 211 {
 212         if ( !d->transferRateTimer )
 213                 d->transferRateTimer = startTimer( TransferRateTimerDelay );
 214
 215         d->transferRate[0] += (bytes - processedAmount(KJob::Bytes));
 216
 217         setProcessedAmount( KJob::Bytes, bytes );
 218         emitPercent( bytes, d->info.size() );
 219 }
 220
 221 void Kopete::Transfer::timerEvent( QTimerEvent *event )
 222 {
 223         if ( event->timerId() != d->transferRateTimer )
 224         {
 225                 KIO::Job::timerEvent( event );
 226                 return;
 227         }
 228
 229         // Calculate average transferRate
 230         qint64 bytesPerSecond = 0;
 231         for ( int i = 0; i < TransferRateWindowLength; ++i )
 232                 bytesPerSecond += d->transferRate[i];
 233
 234         bytesPerSecond /= qint64( TransferRateWindowLength );
 235
 236         for ( int i = TransferRateWindowLength - 2; i >= 0; --i )
 237                 d->transferRate[i + 1] = d->transferRate[i];
 238
 239         d->transferRate[0] = 0;
 240         emitSpeed( bytesPerSecond );
 241
 242         // Stop the timer if there is no activity.
 243         if ( bytesPerSecond == 0 )
 244                 stopTransferRateTimer();
 245 }
 246
 247 void Kopete::Transfer::slotComplete()
 248 {
 249         stopTransferRateTimer();
 250         showHtmlMessage( i18n("File transfer %1 completed.", fileForMessage() ) );
 251         emitResult();
 252 }
 253
 254 void Kopete::Transfer::slotError( int error, const QString &errorText )
 255 {
 256         stopTransferRateTimer();
 257         setError(error);
 258         setErrorText(errorText);
 259
 260         showHtmlMessage( i18n("File transfer %1 failed.", fileForMessage() ) );
 261         emitResult();
 262 }
 263
 264 void Kopete::Transfer::slotResultEmitted()
 265 {
 266         if( error() == KIO::ERR_USER_CANCELED )
 267         {
 268                 stopTransferRateTimer();
 269                 showHtmlMessage( i18n("You cancelled file transfer %1", fileForMessage() ) );
 270                 emit transferCanceled();
 271         }
 272 }
 273
 274 void Kopete::Transfer::slotCancelled()
 275 {
 276         stopTransferRateTimer();
 277         showHtmlMessage( i18n("File transfer %1 cancelled.", fileForMessage() ) );
 278         emitResult();
 279         //slotError( KIO::ERR_ABORTED, i18n("File transfer cancelled.") );
 280 }
 281
 282 bool Kopete::Transfer::showMessage( QString text ) const
 283 {
 284         Kopete::ChatSession *cs = d->info.contact()->manager();
 285         if (! cs)
 286                 return false;
 287
 288         Kopete::Message msg;
 289         msg.setPlainBody( text );
 290         cs->appendMessage( msg );
 291         return true;
 292 }
 293
 294 bool Kopete::Transfer::showHtmlMessage( QString text ) const
 295 {
 296         Kopete::ChatSession *cs = d->info.contact()->manager();
 297         if (! cs)
 298                 return false;
 299
 300         Kopete::Message msg;
 301         msg.setHtmlBody( text );
 302         cs->appendMessage( msg );
 303         return true;
 304 }
 305
 306 QString Kopete::Transfer::fileForMessage() const
 307 {
 308         if( d->info.direction() == Kopete::FileTransferInfo::Incoming )
 309                 return QString( "<a href=\"%1\">%2</a>" ).arg( d->localUrl.url(), Qt::escape( d->localUrl.path() ) );
 310         else
 311                 return Qt::escape( d->info.file() );
 312 }
 313
 314 void Kopete::Transfer::stopTransferRateTimer()
 315 {
 316         if ( d->transferRateTimer )
 317         {
 318                 killTimer( d->transferRateTimer );
 319                 d->transferRateTimer = 0;
 320         }
 321 }
 322
 323 /***************************
 324  *  Kopete::TransferManager  *
 325  ***************************/
 326
 327 Kopete::TransferManager* Kopete::TransferManager::transferManager()
 328 {
 329         static TransferManager s(0L);
 330         return &s;
 331 }
 332
 333 Kopete::TransferManager::TransferManager( QObject *parent ) : QObject( parent )
 334 {
 335 }
 336
 337 Kopete::Transfer* Kopete::TransferManager::addTransfer( Kopete::Contact *contact, const QString& file, const unsigned long size, const QString &recipient, Kopete::FileTransferInfo::KopeteTransferDirection di)
 338 {
 339         return addTransfer( contact, QStringList(file), size, recipient, di );
 340 }
 341
 342 Kopete::Transfer* Kopete::TransferManager::addTransfer( Kopete::Contact *contact, const QStringList& files, const unsigned long size, const QString &recipient, Kopete::FileTransferInfo::KopeteTransferDirection di)
 343 {
 344         // Use message id to make file transfer id unique because we already use it for incoming file transfer.
 345         uint id = Kopete::Message::nextId();
 346         Kopete::FileTransferInfo info(contact, files, size, recipient, di, id);
 347         Kopete::Transfer *trans = new Kopete::Transfer(info, contact);
 348         connect(trans, SIGNAL(result(KJob *)), this, SLOT(slotComplete(KJob *)));
 349         mTransfersMap.insert(id, trans);
 350         return trans;
 351 }
 352
 353 unsigned int Kopete::TransferManager::askIncomingTransfer( Kopete::Contact *contact, const QString& file, const unsigned long size, const QString& description, QString internalId, const QPixmap &preview )
 354 {
 355         return askIncomingTransfer( contact, QStringList( file ), size, description, internalId, preview );
 356 }
 357
 358 unsigned int Kopete::TransferManager::askIncomingTransfer( Kopete::Contact *contact, const QStringList& files, const unsigned long size, const QString& description, QString internalId, const QPixmap &preview )
 359 {
 360         Kopete::ChatSession *cs = contact->manager( Kopete::Contact::CanCreate );
 361         if ( !cs )
 362                 return 0;
 363
 364         const QString dn = contact->metaContact() ? contact->metaContact()->displayName() : contact->contactId();
 365
 366         QString msgFileName;
 367         foreach ( const QString &file, files )
 368         {
 369                 QString trimmedFile = file.trimmed();
 370                 if ( !trimmedFile.isEmpty() )
 371                         msgFileName += trimmedFile + ", ";
 372         }
 373
 374         // Remove ", " from end
 375         if ( msgFileName.size() >= 2 )
 376                 msgFileName = msgFileName.left( msgFileName.size() - 2 );
 377
 378         Kopete::Message msg( contact, cs->myself() );
 379         msg.setType( Kopete::Message::TypeFileTransferRequest );
 380         msg.setDirection( Kopete::Message::Inbound );
 381         msg.setPlainBody( description );
 382         msg.setFileName( msgFileName );
 383         msg.setFileSize( size );
 384         msg.setFilePreview( preview );
 385
 386         Kopete::FileTransferInfo info( contact, files, size, dn, Kopete::FileTransferInfo::Incoming,
 387                                        msg.id(), internalId, preview, (files.count() > 1) );
 388         mTransferRequestInfoMap.insert( msg.id(), info );
 389
 390         cs->appendMessage( msg );
 391
 392         return msg.id();
 393 }
 394
 395 void Kopete::TransferManager::saveIncomingTransfer( unsigned int id )
 396 {
 397         Kopete::FileTransferInfo info = mTransferRequestInfoMap.value( id );
 398         if ( !info.isValid() )
 399                 return;
 400
 401         KConfigGroup cg( KGlobal::config(), "File Transfer" );
 402         const QString defaultPath = cg.readEntry( "defaultPath", QDir::homePath() );
 403         KUrl url = defaultPath + QLatin1String( "/" ) + info.file();
 404
 405         if ( info.saveToDirectory() )
 406                 url = getSaveDir( url );
 407         else
 408                 url = getSaveFile( url );
 409
 410         if ( !url.isValid() )
 411         {
 412                 emit askIncomingDone( id );
 413                 emit refused( info );
 414                 mTransferRequestInfoMap.remove( id );
 415                 return;
 416         }
 417
 418         const QString directory = ( info.saveToDirectory() ) ? url.path() : url.directory();
 419         if( !directory.isEmpty() )
 420                 cg.writeEntry( "defaultPath", directory );
 421
 422         Kopete::Transfer *trans = new Kopete::Transfer( info, url.path() );
 423         connect( trans, SIGNAL(result(KJob *)), this, SLOT(slotComplete(KJob *)) );
 424         mTransfersMap.insert( info.transferId(), trans );
 425         emit askIncomingDone( id );
 426         emit accepted( trans, url.path() );
 427         mTransferRequestInfoMap.remove( id );
 428 }
 429
 430 void Kopete::TransferManager::cancelIncomingTransfer( unsigned int id )
 431 {
 432         Kopete::FileTransferInfo info = mTransferRequestInfoMap.value( id );
 433         if ( !info.isValid() )
 434                 return;
 435
 436         emit askIncomingDone( id );
 437         emit refused( info );
 438         mTransferRequestInfoMap.remove( id );
 439 }
 440
 441 void Kopete::TransferManager::slotComplete(KJob *job)
 442 {
 443         Kopete::Transfer *transfer=dynamic_cast<Kopete::Transfer*>(job);
 444         if(!transfer)
 445                 return;
 446
 447         emit done(transfer);
 448
 449         for( QMap<unsigned, Kopete::Transfer*>::Iterator it = mTransfersMap.begin();
 450              it != mTransfersMap.end(); ++it )
 451         {
 452                 if( it.value() == transfer )
 453                 {
 454                         removeTransfer(it.key());
 455                         break;
 456                 }
 457         }
 458 }
 459
 460 void Kopete::TransferManager::sendFile( const KUrl &file, const QString &fname, unsigned long sz,
 461          bool mustBeLocal,      QObject *sendTo, const char *slot )
 462 {
 463         KUrl url = file;
 464         QString filename;
 465         unsigned int size = 0;
 466
 467         //If the file location is null, then get it from a file open dialog
 468         if( !url.isValid() )
 469                 url = KFileDialog::getOpenUrl( KUrl(), QString::fromLatin1("*"), 0l, i18n( "Kopete File Transfer" ));
 470         else
 471         {
 472                 filename = fname;
 473                 size = sz;
 474         }
 475
 476         if( filename.isEmpty() )
 477                 filename = url.fileName();
 478
 479         if( size == 0 )
 480         {
 481                 KFileItem finfo(KFileItem::Unknown, KFileItem::Unknown, url);
 482                 size = (unsigned long)finfo.size();
 483         }
 484
 485         if( !url.isEmpty() )
 486         {
 487                 if( mustBeLocal && !url.isLocalFile() )
 488                 {
 489                         KMessageBox::queuedMessageBox( Kopete::UI::Global::mainWidget(), KMessageBox::Sorry,
 490                                 i18n( "Sorry, sending files which are not stored locally is not yet supported by this protocol.\n"
 491                                 "Please copy this file to your computer and try again." ) );
 492                 }
 493                 else
 494                 {
 495                         connect( this, SIGNAL(sendFile(const KUrl&, const QString&, unsigned int)), sendTo, slot );
 496                         emit sendFile( url, filename, size );
 497                         disconnect( this, SIGNAL(sendFile(const KUrl&, const QString&, unsigned int)), sendTo, slot );
 498                 }
 499         }
 500 }
 501
 502 void Kopete::TransferManager::removeTransfer( unsigned int id )
 503 {
 504         mTransfersMap.remove(id);
 505         //we don't need to delete the job, the job get deleted itself
 506 }
 507
 508 KUrl Kopete::TransferManager::getSaveFile( const KUrl& startDir ) const
 509 {
 510         KUrl url = startDir;
 511         for ( ;; )
 512         {
 513                 url = KFileDialog::getSaveUrl( url, QLatin1String( "*" ), 0, i18n( "File Transfer" ) );
 514                 if ( !url.isValid() )
 515                         return url;
 516
 517                 if ( !url.isLocalFile() )
 518                 {
 519                         KMessageBox::messageBox( 0, KMessageBox::Sorry, i18n( "You must provide a valid local filename" ) );
 520                         continue;
 521                 }
 522
 523                 QFileInfo fileInfo( url.path() );
 524                 if ( fileInfo.exists() )
 525                 {
 526                         if ( !fileInfo.isWritable() )
 527                         {
 528                                 KMessageBox::messageBox( 0, KMessageBox::Sorry, i18n( "You do not have permission to write to selected file" ) );
 529                                 continue;
 530                         }
 531
 532                         int ret = KMessageBox::warningContinueCancel( 0, i18n( "The file '%1' already exists.\nDo you want to overwrite it ?", url.path() ),
 533                                                                       i18n( "Overwrite File" ), KStandardGuiItem::save() );
 534                         if ( ret == KMessageBox::Cancel )
 535                                 continue;
 536                 }
 537                 else
 538                 {
 539                         QFileInfo dirInfo( url.directory() );
 540                         if ( !dirInfo.isDir() || !dirInfo.exists() )
 541                         {
 542                                 KMessageBox::messageBox( 0, KMessageBox::Sorry, i18n( "The directory %1 does not exist", dirInfo.fileName() ) );
 543                                 continue;
 544                         }
 545                         else if ( !dirInfo.isWritable() )
 546                         {
 547                                 KMessageBox::messageBox( 0, KMessageBox::Sorry, i18n( "You do not have permission to write to selected directory" ) );
 548                                 continue;
 549                         }
 550
 551                 }
 552                 break;
 553         }
 554         return url;
 555 }
 556
 557 KUrl Kopete::TransferManager::getSaveDir( const KUrl& startDir ) const
 558 {
 559         KUrl url = startDir;
 560         for ( ;; )
 561         {
 562                 url = KFileDialog::getExistingDirectoryUrl( url, 0, i18n( "File Transfer" ) );
 563                 if ( !url.isValid() )
 564                         return url;
 565
 566                 if ( !url.isLocalFile() )
 567                 {
 568                         KMessageBox::messageBox( 0, KMessageBox::Sorry, i18n( "You must provide a valid local directory" ) );
 569                         continue;
 570                 }
 571
 572                 QFileInfo dirInfo( url.path() );
 573                 if ( !dirInfo.isDir() || !dirInfo.exists() )
 574                 {
 575                         KMessageBox::messageBox( 0, KMessageBox::Sorry, i18n( "The directory %1 does not exist", dirInfo.filePath() ) );
 576                         continue;
 577                 }
 578                 else if ( !dirInfo.isWritable() )
 579                 {
 580                         KMessageBox::messageBox( 0, KMessageBox::Sorry, i18n( "You do not have permission to write to selected directory" ) );
 581                         continue;
 582                 }
 583                 break;
 584         }
 585         return url;
 586 }
 587
 588 #include "kopetetransfermanager.moc"
 589