src/MediaDevice.cpp

   1 // (c) 2004 Christian Muehlhaeuser <chris@chris.de>
   2 // (c) 2005-2006 Martin Aumueller <aumuell@reserv.at>
   3 // (c) 2005 Seb Ruiz <ruiz@kde.org>
   4 // (c) 2006 T.R.Shashwath <trshash84@gmail.com>
   5 // (c) 2007 Jeff Mitchell <kde-dev@emailgoeshere.com>
   6 // See COPYING file for licensing information
   7
   8
   9 #define DEBUG_PREFIX "MediaDevice"
  10
  11 #include "MediaDevice.h"
  12
  13 #include "amarok.h"
  14 #include "amarokconfig.h"
  15 #include "app.h"
  16 #include "collectiondb.h"
  17 #include "debug.h"
  18 #include "mediabrowser.h"
  19 #include "MediaItem.h"
  20 #include "metabundle.h"
  21 #include "mountpointmanager.h"
  22 #include "pluginmanager.h"
  23 #include "podcastbundle.h"
  24 #include "scriptmanager.h"
  25 #include "statusbar.h"
  26
  27 #include <KIO/Job>
  28 #include <KMessageBox>
  29
  30 MediaDevice::MediaDevice()
  31     : Amarok::Plugin()
  32     , m_name( QString() )
  33     , m_hasMountPoint( true )
  34     , m_autoDeletePodcasts( false )
  35     , m_syncStats( false )
  36     , m_transcode( false )
  37     , m_transcodeAlways( false )
  38     , m_transcodeRemove( false )
  39     , sysProc ( 0 )
  40     , m_parent( 0 )
  41     , m_view( 0 )
  42     , m_uid( QString() )
  43     , m_deviceNode( QString() )
  44     , m_mountPoint( QString() )
  45     , m_fsType( QString() )
  46     , m_wait( false )
  47     , m_requireMount( false )
  48     , m_canceled( false )
  49     , m_transferring( false )
  50     , m_deleting( false )
  51     , m_deferredDisconnect( false )
  52     , m_scheduledDisconnect( false )
  53     , m_transfer( true )
  54     , m_configure( true )
  55     , m_customButton( false )
  56     , m_playlistItem( 0 )
  57     , m_podcastItem( 0 )
  58     , m_invisibleItem( 0 )
  59     , m_staleItem( 0 )
  60     , m_orphanedItem( 0 )
  61 {
  62     sysProc = new K3ShellProcess(); Q_CHECK_PTR(sysProc);
  63 }
  64
  65 void MediaDevice::init( MediaBrowser* parent )
  66 {
  67     m_parent = parent;
  68     if( !m_view )
  69        m_view = new MediaView( m_parent->m_views, this );
  70     m_view->hide();
  71 }
  72
  73 MediaDevice::~MediaDevice()
  74 {
  75     delete m_view;
  76     delete sysProc;
  77 }
  78
  79 bool
  80 MediaDevice::isSpecialItem( MediaItem *item )
  81 {
  82     return (item == m_playlistItem) ||
  83         (item == m_podcastItem) ||
  84         (item == m_invisibleItem) ||
  85         (item == m_staleItem) ||
  86         (item == m_orphanedItem);
  87 }
  88
  89 void
  90 MediaDevice::loadConfig()
  91 {
  92     m_transcode = configBool( "Transcode" );
  93     m_transcodeAlways = configBool( "TranscodeAlways" );
  94     m_transcodeRemove = configBool( "TranscodeRemove" );
  95     m_preconnectcmd = configString( "PreConnectCommand" );
  96     if( m_preconnectcmd.isEmpty() )
  97         m_preconnectcmd = configString( "MountCommand" );
  98     m_postdisconnectcmd = configString( "PostDisconnectCommand" );
  99     if( m_postdisconnectcmd.isEmpty() )
 100         m_postdisconnectcmd = configString( "UmountCommand" );
 101     if( m_requireMount && m_postdisconnectcmd.isEmpty() )
 102         m_postdisconnectcmd = "kdeeject -q %d";
 103 }
 104
 105 QString
 106 MediaDevice::configString( const QString &name, const QString &defValue )
 107 {
 108     QString configName = "MediaDevice";
 109     if( !uid().isEmpty() )
 110         configName += '_' + uid();
 111     KConfigGroup config = Amarok::config( configName );
 112     return config.readEntry( name, defValue );
 113 }
 114
 115 void
 116 MediaDevice::setConfigString( const QString &name, const QString &value )
 117 {
 118     QString configName = "MediaDevice";
 119     if( !uid().isEmpty() )
 120         configName += '_' + uid();
 121     KConfigGroup config = Amarok::config( configName );
 122     config.writeEntry( name, value );
 123 }
 124
 125 bool
 126 MediaDevice::configBool( const QString &name, bool defValue )
 127 {
 128     QString configName = "MediaDevice";
 129     if( !uid().isEmpty() )
 130         configName += '_' + uid();
 131     KConfigGroup config = Amarok::config( configName );
 132     return config.readEntry( name, defValue );
 133 }
 134
 135 void
 136 MediaDevice::setConfigBool( const QString &name, bool value )
 137 {
 138     QString configName = "MediaDevice";
 139     if( !uid().isEmpty() )
 140         configName += '_' + uid();
 141     KConfigGroup config = Amarok::config( configName );
 142     config.writeEntry( name, value );
 143 }
 144
 145 MediaView *
 146 MediaDevice::view()
 147 {
 148     return m_view;
 149 }
 150
 151 void
 152 MediaDevice::hideProgress()
 153 {
 154     m_parent->m_progressBox->hide();
 155 }
 156
 157 void
 158 MediaDevice::updateRootItems()
 159 {
 160     if(m_podcastItem)
 161         m_podcastItem->setVisible(m_podcastItem->childCount() > 0);
 162     if(m_invisibleItem)
 163         m_invisibleItem->setVisible(m_invisibleItem->childCount() > 0);
 164     if(m_staleItem)
 165         m_staleItem->setVisible(m_staleItem->childCount() > 0);
 166     if(m_orphanedItem)
 167         m_orphanedItem->setVisible(m_orphanedItem->childCount() > 0);
 168 }
 169
 170 BundleList
 171 MediaDevice::bundlesToSync( const QString &name, const KUrl &url )
 172 {
 173     //PORT 2.0
 174 //    BundleList bundles;
 175 //    if( !PlaylistFile::isPlaylistFile( url ) )
 176 //    {
 177 //        Amarok::StatusBar::instance()->longMessage( i18n( "Not a playlist file: %1", url.path() ),
 178 //                KDE::StatusBar::Sorry );
 179 //        return bundles;
 180 //    }
 181 //
 182 //    PlaylistFile playlist( url.path() );
 183 //    if( playlist.isError() )
 184 //    {
 185 //        Amarok::StatusBar::instance()->longMessage( i18n( "Failed to load playlist: %1", url.path() ),
 186 //                KDE::StatusBar::Sorry );
 187 //        return bundles;
 188 //    }
 189 //
 190 //    for( BundleList::iterator it = playlist.bundles().begin();
 191 //            it != playlist.bundles().end();
 192 //            ++it )
 193 //    {
 194 //        bundles += MetaBundle( (*it).url() );
 195 //    }
 196 //    preparePlaylistForSync( name, bundles );
 197 //    return bundles;
 198 }
 199
 200 BundleList
 201 MediaDevice::bundlesToSync( const QString &name, const QString &query )
 202 {
 203 //    const QStringList values = CollectionDB::instance()->query( query );
 204 //
 205 //    BundleList bundles;
 206 //    for( QStringList::const_iterator it = values.begin(); it != values.end(); ++it )
 207 //        bundles += CollectionDB::instance()->bundleFromQuery( &it );
 208 //    preparePlaylistForSync( name, bundles );
 209 //    return bundles;
 210 }
 211
 212 void
 213 MediaDevice::preparePlaylistForSync( const QString &name, const BundleList &bundles )
 214 {
 215     if( ! m_playlistItem ) // might be syncing a new playlist from the playlist browser
 216         return;
 217     MediaItem *pl = m_playlistItem->findItem( name );
 218     if( pl )
 219     {
 220         MediaItem *next = 0;
 221         for( MediaItem *it = static_cast<MediaItem *>(pl->firstChild());
 222                 it;
 223                 it = next )
 224         {
 225             next = static_cast<MediaItem *>(it->nextSibling());
 226             const MetaBundle *bundle = (*it).bundle();
 227             if( !bundle )
 228                 continue;
 229             if( isOnOtherPlaylist( name, *bundle ) )
 230                 continue;
 231             if( isInBundleList( bundles, *bundle ) )
 232                 continue;
 233             deleteItemFromDevice( it );
 234         }
 235         deleteItemFromDevice( pl, None );
 236     }
 237     purgeEmptyItems();
 238 }
 239
 240 bool
 241 MediaDevice::bundleMatch( const MetaBundle &b1, const MetaBundle &b2 )
 242 {
 243     if( b1.track() != b2.track() )
 244         return false;
 245     if( b1.title() != b2.title() )
 246         return false;
 247     if( b1.album() != b2.album() )
 248         return false;
 249     if( b1.artist() != b2.artist() )
 250         return false;
 251 #if 0
 252     if( b1.discNumber() != b2.discNumber() )
 253         return false;
 254     if( b1.composer() != b2.composer() )
 255         return false;
 256 #endif
 257
 258     return true;
 259 }
 260
 261 bool
 262 MediaDevice::isInBundleList( const BundleList &bundles, const MetaBundle &b )
 263 {
 264     for( BundleList::const_iterator it = bundles.begin();
 265             it != bundles.end();
 266             ++it )
 267     {
 268         if( bundleMatch( b, *it ) )
 269             return true;
 270     }
 271
 272     return false;
 273 }
 274
 275 bool
 276 MediaDevice::isOnOtherPlaylist( const QString &playlistToAvoid, const MetaBundle &bundle )
 277 {
 278     for( MediaItem *it = static_cast<MediaItem *>(m_playlistItem->firstChild());
 279             it;
 280             it = static_cast<MediaItem *>(it->nextSibling()) )
 281     {
 282         if( it->text( 0 )  == playlistToAvoid )
 283             continue;
 284         if( isOnPlaylist( *it, bundle ) )
 285             return true;
 286     }
 287
 288     return false;
 289 }
 290
 291 bool
 292 MediaDevice::isOnPlaylist( const MediaItem &playlist, const MetaBundle &bundle )
 293 {
 294     for( MediaItem *it = static_cast<MediaItem *>(playlist.firstChild());
 295             it;
 296             it = static_cast<MediaItem *>(it->nextSibling()) )
 297     {
 298         const MetaBundle *b = (*it).bundle();
 299         if( !b )
 300             continue;
 301         if( bundleMatch( *b, bundle ) )
 302             return true;
 303     }
 304
 305     return false;
 306 }
 307
 308 void
 309 MediaDevice::copyTrackFromDevice( MediaItem *item )
 310 {
 311     debug() << "copyTrackFromDevice: not copying " << item->url() << ": not implemented";
 312 }
 313
 314 QString
 315 MediaDevice::replaceVariables( const QString &cmd )
 316 {
 317     QString result = cmd;
 318     result.replace( "%d", deviceNode() );
 319     result.replace( "%m", mountPoint() );
 320     return result;
 321 }
 322
 323 int MediaDevice::runPreConnectCommand()
 324 {
 325     if( m_preconnectcmd.isEmpty() )
 326         return 0;
 327
 328     QString cmd = replaceVariables( m_preconnectcmd );
 329
 330     debug() << "running pre-connect command: [" << cmd << "]";
 331     int e=sysCall(cmd);
 332     debug() << "pre-connect: e=" << e;
 333     return e;
 334 }
 335
 336 int MediaDevice::runPostDisconnectCommand()
 337 {
 338     if( m_postdisconnectcmd.isEmpty() )
 339         return 0;
 340
 341     QString cmd = replaceVariables( m_postdisconnectcmd );
 342     debug() << "running post-disconnect command: [" << cmd << "]";
 343     int e=sysCall(cmd);
 344     debug() << "post-disconnect: e=" << e;
 345
 346     return e;
 347 }
 348
 349 int MediaDevice::sysCall( const QString &command )
 350 {
 351     if ( sysProc->isRunning() )  return -1;
 352
 353     sysProc->clearArguments();
 354     (*sysProc) << command;
 355     if (!sysProc->start( K3Process::Block, K3Process::AllOutput ))
 356         kFatal() << i18n("could not execute %1", command.toLocal8Bit().data());
 357
 358     return (sysProc->exitStatus());
 359 }
 360
 361 void
 362 MediaDevice::abortTransfer()
 363 {
 364     setCanceled( true );
 365     cancelTransfer();
 366 }
 367
 368 bool
 369 MediaDevice::kioCopyTrack( const KUrl &src, const KUrl &dst )
 370 {
 371     m_wait = true;
 372
 373     KIO::FileCopyJob *job = KIO::file_copy( src, dst,
 374             -1 /* permissions */,
 375             KIO::HideProgressInfo );
 376     connect( job, SIGNAL( result( KIO::Job * ) ),
 377             this,  SLOT( fileTransferred( KIO::Job * ) ) );
 378
 379     bool tryToRemove = false;
 380     while ( m_wait )
 381     {
 382         if( isCanceled() )
 383         {
 384             job->kill( KJob::EmitResult );
 385             tryToRemove = true;
 386             m_wait = false;
 387         }
 388         else
 389         {
 390             usleep(10000);
 391             kapp->processEvents( QEventLoop::ExcludeUserInputEvents );
 392         }
 393     }
 394
 395     if( !tryToRemove )
 396     {
 397         if(m_copyFailed)
 398         {
 399             tryToRemove = true;
 400             Amarok::StatusBar::instance()->longMessage(
 401                     i18n( "Media Device: Copying %1 to %2 failed" )
 402                     .arg( src.prettyUrl(), dst.prettyUrl() ),
 403                     KDE::StatusBar::Error );
 404         }
 405         else
 406         {
 407             MetaBundle bundle2(dst);
 408             if(!bundle2.isValidMedia() && bundle2.filesize()==MetaBundle::Undetermined)
 409             {
 410                 tryToRemove = true;
 411                 // probably s.th. went wrong
 412                 Amarok::StatusBar::instance()->longMessage(
 413                         i18n( "Media Device: Reading tags from %1 failed", dst.prettyUrl() ),
 414                         KDE::StatusBar::Error );
 415             }
 416         }
 417     }
 418
 419     if( tryToRemove )
 420     {
 421         QFile::remove( dst.path() );
 422         return false;
 423     }
 424
 425     return true;
 426 }
 427
 428 void
 429 MediaDevice::fileTransferred( KIO::Job *job )  //SLOT
 430 {
 431     if(job->error())
 432     {
 433         m_copyFailed = true;
 434         debug() << "file transfer failed: " << job->errorText();
 435     }
 436     else
 437     {
 438         m_copyFailed = false;
 439     }
 440
 441     m_wait = false;
 442 }
 443
 444 bool
 445 MediaDevice::connectDevice( bool silent )
 446 {
 447     if( !lockDevice( true ) )
 448         return false;
 449
 450     runPreConnectCommand();
 451     openDevice( silent );
 452
 453     if( isConnected()
 454             && MediaBrowser::instance()->currentDevice() != this
 455             && MediaBrowser::instance()->currentDevice()
 456             && !MediaBrowser::instance()->currentDevice()->isConnected() )
 457     {
 458         MediaBrowser::instance()->activateDevice( this );
 459     }
 460     m_parent->updateStats();
 461     m_parent->updateButtons();
 462
 463     if( !isConnected() )
 464     {
 465         unlockDevice();
 466         return false;
 467     }
 468
 469     if( m_syncStats )
 470     {
 471         syncStatsFromDevice( 0 );
 472         Scrobbler::instance()->m_submitter->syncComplete();
 473     }
 474
 475     // delete podcasts already played
 476     if( m_autoDeletePodcasts && m_podcastItem )
 477     {
 478         QList<MediaItem*> list;
 479         //NOTE we assume that currentItem is the main target
 480         int numFiles  = m_view->getSelectedLeaves( m_podcastItem, &list, MediaView::OnlyPlayed );
 481
 482         if(numFiles > 0)
 483         {
 484             m_parent->m_stats->setText( i18np( "1 track to be deleted", "%1 tracks to be deleted", numFiles ) );
 485
 486             setProgress( 0, numFiles );
 487
 488             int numDeleted = deleteItemFromDevice( m_podcastItem, true );
 489             purgeEmptyItems();
 490             if( numDeleted < 0 )
 491             {
 492                 Amarok::StatusBar::instance()->longMessage(
 493                         i18n( "Failed to purge podcasts already played" ),
 494                         KDE::StatusBar::Sorry );
 495             }
 496             else if( numDeleted > 0 )
 497             {
 498                 Amarok::StatusBar::instance()->shortMessage(
 499                         i18np( "Purged 1 podcasts already played",
 500                             "Purged %1 podcasts already played",
 501                             numDeleted ) );
 502             }
 503
 504             synchronizeDevice();
 505
 506             QTimer::singleShot( 1500, m_parent->m_progressBox, SLOT(hide()) );
 507             m_parent->queue()->computeSize();
 508             m_parent->updateStats();
 509         }
 510     }
 511     unlockDevice();
 512
 513     updateRootItems();
 514
 515     if( m_deferredDisconnect )
 516     {
 517         m_deferredDisconnect = false;
 518         disconnectDevice( m_runDisconnectHook );
 519     }
 520
 521     Amarok::StatusBar::instance()->shortMessage( i18n( "Device successfully connected" ) );
 522
 523     m_parent->updateDevices();
 524
 525     return true;
 526 }
 527
 528 bool
 529 MediaDevice::disconnectDevice( bool postDisconnectHook )
 530 {
 531     DEBUG_BLOCK
 532
 533     abortTransfer();
 534
 535     debug() << "disconnecting: hook=" << postDisconnectHook;
 536
 537     if( !lockDevice( true ) )
 538     {
 539         m_runDisconnectHook = postDisconnectHook;
 540         m_deferredDisconnect = true;
 541         debug() << "disconnecting: locked";
 542         return false;
 543     }
 544     debug() << "disconnecting: ok";
 545
 546     if( m_syncStats )
 547     {
 548         syncStatsToDevice();
 549     }
 550
 551     closeDevice();
 552     unlockDevice();
 553
 554     m_parent->updateStats();
 555
 556     bool result = true;
 557     if( postDisconnectHook && runPostDisconnectCommand() != 0 )
 558     {
 559         Amarok::StatusBar::instance()->longMessage(
 560                 i18n( "Post-disconnect command failed, before removing device, please make sure that it is safe to do so." ),
 561                 KDE::StatusBar::Information );
 562         result = false;
 563     }
 564     else
 565         Amarok::StatusBar::instance()->shortMessage( i18n( "Device successfully disconnected" ) );
 566
 567     m_parent->updateDevices();
 568
 569     return result;
 570 }
 571
 572 void
 573 MediaDevice::syncStatsFromDevice( MediaItem *root )
 574 {
 575     MediaItem *it = static_cast<MediaItem *>( m_view->firstChild() );
 576     if( root )
 577     {
 578         it = static_cast<MediaItem *>( root->firstChild() );
 579     }
 580
 581     kapp->processEvents( QEventLoop::ExcludeUserInputEvents );
 582
 583     for( ; it; it = static_cast<MediaItem *>( it->nextSibling() ) )
 584     {
 585         switch( it->type() )
 586         {
 587         case MediaItem::TRACK:
 588             if( !it->parent() || static_cast<MediaItem *>( it->parent() )->type() != MediaItem::PLAYLIST )
 589             {
 590                 const MetaBundle *bundle = it->bundle();
 591                 for( int i=0; i<it->recentlyPlayed(); i++ )
 592                 {
 593                     // submit to last.fm
 594                     if( bundle->length() > 30
 595                             && !bundle->artist().isEmpty() && bundle->artist() != i18n( "Unknown" )
 596                             && !bundle->title().isEmpty() && bundle->title() != i18n( "Unknown" ) )
 597                     {
 598                         // don't submit tracks shorter than 30 sec or w/o artist/title
 599                         debug() << "scrobbling " << bundle->artist() << " - " << bundle->title();
 600                         SubmitItem *sit = new SubmitItem( bundle->artist(), bundle->album(), bundle->title(), bundle->length(), false /* fake time */ );
 601                         Scrobbler::instance()->m_submitter->submitItem( sit );
 602                     }
 603
 604                     // increase Amarok playcount
 605                     QString url = CollectionDB::instance()->getURL( *bundle );
 606                     if( !url.isEmpty() )
 607                     {
 608                         QDateTime t = it->playTime();
 609                         CollectionDB::instance()->addSongPercentage( url, 100, "mediadevice", t.isValid() ? &t : 0 );
 610                         debug() << "played " << url;
 611                     }
 612                 }
 613
 614                 if( it->ratingChanged() )
 615                 {
 616                     // copy rating from media device to Amarok
 617                     QString url = CollectionDB::instance()->getURL( *bundle );
 618                     debug() << "rating changed " << url << ": " << it->rating()/10;
 619                     if( !url.isEmpty() )
 620                     {
 621                         CollectionDB::instance()->setSongRating( url, it->rating()/10 );
 622                         it->setRating( it->rating() ); // prevent setting it again next time
 623                     }
 624                 }
 625             }
 626             break;
 627         case MediaItem::PODCASTITEM:
 628             if( !it->parent() || static_cast<MediaItem *>( it->parent() )->type() != MediaItem::PLAYLIST )
 629             {
 630                 const MetaBundle *bundle = it->bundle();
 631                 if( it->played() || it->recentlyPlayed() )
 632                 {
 633                     if( PodcastEpisodeBundle *peb = bundle->podcastBundle() )
 634                     {
 635                         debug() << "marking podcast episode as played: " << peb->url();
 636 //PORT 2.0
 637 //                         if( PlaylistBrowser::instance() )
 638 //                         {
 639 //                             PodcastEpisode *p = PlaylistBrowser::instance()->findPodcastEpisode( peb->url(), peb->parent() );
 640 //                             if ( p )
 641 //                                 p->setListened();
 642 //                             else
 643 //                                 debug() << "did not find podcast episode: " << peb->url() << " from " << peb->parent();
 644 //                         }
 645                     }
 646                 }
 647             }
 648             break;
 649
 650         default:
 651             syncStatsFromDevice( it );
 652             break;
 653         }
 654     }
 655 }
 656
 657 void
 658 MediaDevice::syncStatsToDevice( MediaItem *root )
 659 {
 660     MediaItem *it = static_cast<MediaItem *>( m_view->firstChild() );
 661     if( root )
 662     {
 663         it = static_cast<MediaItem *>( root->firstChild() );
 664     }
 665
 666     kapp->processEvents( QEventLoop::ExcludeUserInputEvents );
 667
 668     for( ; it; it = static_cast<MediaItem *>( it->nextSibling() ) )
 669     {
 670         switch( it->type() )
 671         {
 672         case MediaItem::TRACK:
 673             if( !it->parent() || static_cast<MediaItem *>( it->parent() )->type() != MediaItem::PLAYLIST )
 674             {
 675                 const MetaBundle *bundle = it->bundle();
 676                 QString url = CollectionDB::instance()->getURL( *bundle );
 677                 it->syncStatsFromPath( url );
 678             }
 679             break;
 680
 681         case MediaItem::PODCASTITEM:
 682             if( !it->parent() || static_cast<MediaItem *>( it->parent() )->type() != MediaItem::PLAYLIST )
 683             {
 684                 const MetaBundle *bundle = it->bundle();
 685                 if( PodcastEpisodeBundle *peb = bundle->podcastBundle() )
 686                 {
 687 // //PORT 2.0
 688 //                     if( PlaylistBrowser::instance() )
 689 //                     {
 690 //                         PodcastEpisode *p = PlaylistBrowser::instance()->findPodcastEpisode( peb->url(), peb->parent() );
 691 //                         if( p )
 692 //                             it->setListened( !p->isNew() );
 693 //                     }
 694                 }
 695             }
 696             break;
 697
 698         default:
 699             syncStatsToDevice( it );
 700             break;
 701         }
 702     }
 703 }
 704
 705 void
 706 MediaDevice::transferFiles()
 707 {
 708     if( !lockDevice( true ) )
 709     {
 710         return;
 711     }
 712
 713     setCanceled( false );
 714
 715     m_transferring = true;
 716     m_parent->transferAction()->setEnabled( false );
 717
 718     setProgress( 0, m_parent->m_queue->childCount() );
 719
 720     // ok, let's copy the stuff to the device
 721
 722     KUrl::List existing, unplayable;
 723     unsigned transcodeFail = 0;
 724     // iterate through items
 725     MediaItem *next = static_cast<MediaItem *>(m_parent->m_queue->firstChild());
 726     while( next )
 727     {
 728         MediaItem *transferredItem = next;
 729         transferredItem->setFailed( false );
 730         transferredItem->m_flags |= MediaItem::Transferring;
 731         next = static_cast<MediaItem *>( transferredItem->nextSibling() );
 732
 733         if( transferredItem->device() )
 734         {
 735             transferredItem->device()->copyTrackFromDevice( transferredItem );
 736             m_parent->m_queue->subtractItemFromSize( transferredItem, true );
 737             delete transferredItem;
 738             setProgress( progress() + 1 );
 739             m_parent->m_queue->itemCountChanged();
 740             kapp->processEvents( QEventLoop::ExcludeUserInputEvents );
 741             continue;
 742         }
 743
 744         BundleList bundles;
 745         if( transferredItem->type() == MediaItem::PLAYLIST )
 746         {
 747             if( transferredItem->flags() & MediaItem::SmartPlaylist )
 748                 bundles = bundlesToSync( transferredItem->text( 0 ), transferredItem->data() );
 749             else
 750                 bundles = bundlesToSync( transferredItem->text( 0 ), KUrl( transferredItem->data() ) );
 751         }
 752         else if( transferredItem->bundle() )
 753             bundles += *transferredItem->bundle();
 754         else
 755         {
 756             // this should not happen
 757             debug() << "invalid item in transfer queue";
 758             m_parent->m_queue->subtractItemFromSize( transferredItem, true );
 759             delete transferredItem;
 760             m_parent->m_queue->itemCountChanged();
 761             continue;
 762         }
 763
 764         if( bundles.count() > 1 )
 765             setProgress( progress(), MediaBrowser::instance()->m_progress->maximum() + bundles.count() - 1 );
 766
 767         QString playlist = transferredItem->m_playlistName;
 768         for( BundleList::const_iterator it = bundles.begin();
 769                 it != bundles.end();
 770                 ++it )
 771         {
 772             if( isCanceled() )
 773                 break;
 774
 775             const MetaBundle *bundle = &(*it);
 776
 777             bool transcoding = false;
 778             MediaItem *item = trackExists( *bundle );
 779             if( item && playlist.isEmpty() )
 780             {
 781                 Amarok::StatusBar::instance()->shortMessage( i18n( "Track already on media device: %1" ).
 782                         arg( (*it).url().prettyUrl() ),
 783                         KDE::StatusBar::Sorry );
 784                 existing += (*it).url();
 785                 setProgress( progress() + 1 );
 786                 continue;
 787             }
 788             else if( !item ) // the item does not yet exist on the media device
 789             {
 790                 if( m_transcode && ( !isPlayable( *bundle ) || m_transcodeAlways ) )
 791                 {
 792                     QString preferred = supportedFiletypes().isEmpty() ? "mp3" : supportedFiletypes().first();
 793                     debug() << "transcoding " << bundle->url() << " to " << preferred;
 794                     KUrl transcoded = MediaBrowser::instance()->transcode( bundle->url(), preferred );
 795                     if( isCanceled() )
 796                         break;
 797                     if( transcoded.isEmpty() )
 798                     {
 799                         debug() << "transcoding failed";
 800                         transcodeFail++;
 801                     }
 802                     else
 803                     {
 804                         transcoding = true;
 805                         MetaBundle *transcodedBundle = new MetaBundle( transcoded );
 806                         transcodedBundle->setArtist( bundle->artist() );
 807                         transcodedBundle->setTitle( bundle->title() );
 808                         transcodedBundle->setComposer( bundle->composer() );
 809                         transcodedBundle->setAlbum( bundle->album() );
 810                         transcodedBundle->setGenre( bundle->genre() );
 811                         transcodedBundle->setComment( bundle->comment() );
 812                         transcodedBundle->setYear( bundle->year() );
 813                         transcodedBundle->setDiscNumber( bundle->discNumber() );
 814                         transcodedBundle->setTrack( bundle->track() );
 815                         if( bundle->podcastBundle() )
 816                         {
 817                             transcodedBundle->setPodcastBundle( *bundle->podcastBundle() );
 818                             transcodedBundle->copyFrom( *bundle->podcastBundle() );
 819                         }
 820                         bundle = transcodedBundle;
 821                     }
 822                 }
 823
 824                 if( !isPlayable( *bundle ) )
 825                 {
 826                     Amarok::StatusBar::instance()->shortMessage( i18n( "Track not playable on media device: %1", bundle->url().path() ),
 827                             KDE::StatusBar::Sorry );
 828                     unplayable += (*it).url();
 829                     transferredItem->setFailed();
 830                     if( transcoding )
 831                     {
 832                         delete bundle;
 833                         bundle = 0;
 834                     }
 835                     setProgress( progress() + 1 );
 836                     continue;
 837                 }
 838                 item = copyTrackToDevice( *bundle );
 839             }
 840
 841             if( !item ) // copyTrackToDevice() failed
 842             {
 843                 if( !isCanceled() )
 844                 {
 845                     Amarok::StatusBar::instance()->longMessage(
 846                             i18n( "Failed to copy track to media device: %1", bundle->url().path() ),
 847                             KDE::StatusBar::Sorry );
 848                     transferredItem->setFailed();
 849                 }
 850             }
 851
 852             if( transcoding )
 853             {
 854                 if( m_transcodeRemove )
 855                     QFile( bundle->url().path() ).remove();
 856
 857                 delete bundle;
 858                 bundle = 0;
 859             }
 860
 861             if( isCanceled() )
 862                 break;
 863
 864             if( !item )
 865             {
 866                 setProgress( progress() + 1 );
 867                 continue;
 868             }
 869
 870             item->syncStatsFromPath( (*it).url().path() );
 871
 872             if( m_playlistItem && !playlist.isEmpty() )
 873             {
 874                 MediaItem *pl = m_playlistItem->findItem( playlist );
 875                 if( !pl )
 876                 {
 877                     QList<MediaItem*> items;
 878                     pl = newPlaylist( playlist, m_playlistItem, items );
 879                 }
 880                 if( pl )
 881                 {
 882                     QList<MediaItem*> items;
 883                     items.append( item );
 884                     addToPlaylist( pl, pl->lastChild(), items );
 885                 }
 886             }
 887
 888             setProgress( progress() + 1 );
 889         }
 890
 891         transferredItem->m_flags &= ~MediaItem::Transferring;
 892
 893         if( isCanceled() )
 894         {
 895             m_parent->updateStats();
 896             break;
 897         }
 898
 899         if( !(transferredItem->flags() & MediaItem::Failed) )
 900         {
 901             m_parent->m_queue->subtractItemFromSize( transferredItem, true );
 902             delete transferredItem;
 903             m_parent->m_queue->itemCountChanged();
 904         }
 905         m_parent->updateStats();
 906
 907         kapp->processEvents( QEventLoop::ExcludeUserInputEvents );
 908     }
 909     synchronizeDevice();
 910     unlockDevice();
 911     fileTransferFinished();
 912
 913     QString msg;
 914     if( unplayable.count() > 0 )
 915     {
 916         msg = i18np( "One track not playable on media device",
 917                 "%1 tracks not playable on media device", unplayable.count() );
 918     }
 919     if( existing.count() > 0 )
 920     {
 921         if( msg.isEmpty() )
 922             msg = i18np( "One track already on media device",
 923                     "%1 tracks already on media device", existing.count() );
 924         else
 925             msg += i18np( ", one track already on media device",
 926                     ", %1 tracks already on media device", existing.count() );
 927     }
 928     if( transcodeFail > 0 )
 929     {
 930         if( msg.isEmpty() )
 931             msg = i18np( "One track was not transcoded",
 932                     "%1 tracks were not transcoded", transcodeFail );
 933         else
 934             msg += i18np( ", one track was not transcoded",
 935                     ", %1 tracks were not transcoded", transcodeFail );
 936
 937         const ScriptManager* const sm = ScriptManager::instance();
 938         if( !sm->transcodeScriptRunning().isEmpty() )
 939             msg += i18n( " (no transcode script running)" );
 940     }
 941
 942     if( unplayable.count() + existing.count() > 0 )
 943     {
 944         QString longMsg = i18n( "The following tracks were not transferred: ");
 945         for( KUrl::List::Iterator it = existing.begin();
 946                 it != existing.end();
 947                 it++ )
 948         {
 949             longMsg += "<br>" + (*it).prettyUrl();
 950         }
 951         for( KUrl::List::Iterator it = unplayable.begin();
 952                 it != unplayable.end();
 953                 it++ )
 954         {
 955             longMsg += "<br>" + (*it).prettyUrl();
 956         }
 957         Amarok::StatusBar::instance()->shortLongMessage( msg, longMsg, KDE::StatusBar::Sorry );
 958     }
 959     else if( !msg.isEmpty() )
 960     {
 961         Amarok::StatusBar::instance()->shortMessage( msg, KDE::StatusBar::Sorry );
 962     }
 963
 964     m_parent->updateButtons();
 965     m_parent->queue()->save( Amarok::saveLocation() + "transferlist.xml" );
 966     m_transferring = false;
 967
 968     if( m_deferredDisconnect )
 969     {
 970         m_deferredDisconnect = false;
 971         disconnectDevice( m_runDisconnectHook );
 972     }
 973     else if( m_scheduledDisconnect )
 974     {
 975         disconnectDevice( true );
 976     }
 977     m_scheduledDisconnect = false;
 978 }
 979
 980 int
 981 MediaDevice::progress() const
 982 {
 983     return m_parent->m_progress->value();
 984 }
 985
 986 void
 987 MediaDevice::setProgress( const int progress, const int total )
 988 {
 989     if( total != -1 )
 990         m_parent->m_progress->setRange( 0, total );
 991     m_parent->m_progress->setValue( progress );
 992     m_parent->m_progressBox->show();
 993 }
 994
 995 void
 996 MediaDevice::fileTransferFinished()  //SLOT
 997 {
 998     m_parent->updateStats();
 999     m_parent->m_progressBox->hide();
1000     m_parent->transferAction()->setEnabled( isConnected() && m_parent->queue()->childCount() > 0 );
1001     m_wait = false;
1002 }
1003
1004
1005 int
1006 MediaDevice::deleteFromDevice(MediaItem *item, int flags )
1007 {
1008     MediaItem* fi = item;
1009     int count = 0;
1010
1011     if ( !(flags & Recursing) )
1012     {
1013         if( !lockDevice( true ) )
1014             return 0;
1015
1016         setCanceled( false );
1017
1018         m_deleting = true;
1019
1020         QList<MediaItem*> list;
1021         //NOTE we assume that currentItem is the main target
1022         int numFiles  = m_view->getSelectedLeaves(item, &list, MediaView::OnlySelected | ((flags & OnlyPlayed) ? MediaView::OnlyPlayed : MediaView::None) );
1023
1024         m_parent->m_stats->setText( i18np( "1 track to be deleted", "%1 tracks to be deleted", numFiles ) );
1025         if( numFiles > 0 && (flags & DeleteTrack) )
1026         {
1027             int button = KMessageBox::warningContinueCancel( m_parent,
1028                     i18np( "<p>You have selected 1 track to be <b>irreversibly</b> deleted.",
1029                         "<p>You have selected %1 tracks to be <b>irreversibly</b> deleted.",
1030                         numFiles
1031                         ),
1032                     QString(),
1033                     KGuiItem(i18n("&Delete"),"edit-delete") );
1034
1035             if ( button != KMessageBox::Continue )
1036             {
1037                 m_parent->queue()->computeSize();
1038                 m_parent->updateStats();
1039                 m_deleting = false;
1040                 unlockDevice();
1041                 return 0;
1042             }
1043
1044             if(!isTransferring())
1045             {
1046                 setProgress( 0, numFiles );
1047             }
1048
1049         }
1050         // don't return if numFiles==0: playlist items might be to delete
1051
1052         if( !fi )
1053             fi = static_cast<MediaItem*>(m_view->firstChild());
1054     }
1055
1056     while( fi )
1057     {
1058         MediaItem *next = static_cast<MediaItem*>(fi->nextSibling());
1059
1060         if( isCanceled() )
1061         {
1062             break;
1063         }
1064
1065         if( !fi->isVisible() )
1066         {
1067             fi = next;
1068             continue;
1069         }
1070
1071         if( fi->isSelected() )
1072         {
1073             int ret = deleteItemFromDevice(fi, flags);
1074             if( ret >= 0 && count >= 0 )
1075                 count += ret;
1076             else
1077                 count = -1;
1078         }
1079         else
1080         {
1081             if( fi->childCount() )
1082             {
1083                 int ret = deleteFromDevice( static_cast<MediaItem*>(fi->firstChild()), flags | Recursing );
1084                 if( ret >= 0 && count >= 0 )
1085                     count += ret;
1086                 else
1087                     count = -1;
1088             }
1089         }
1090         m_parent->updateStats();
1091
1092         fi = next;
1093     }
1094
1095     if(!(flags & Recursing))
1096     {
1097         purgeEmptyItems();
1098         synchronizeDevice();
1099         m_deleting = false;
1100         unlockDevice();
1101
1102         if(!isTransferring())
1103         {
1104             QTimer::singleShot( 1500, m_parent->m_progressBox, SLOT(hide()) );
1105         }
1106
1107         if( m_deferredDisconnect )
1108         {
1109             m_deferredDisconnect = false;
1110             disconnectDevice( m_runDisconnectHook );
1111         }
1112     }
1113     m_parent->queue()->computeSize();
1114     m_parent->updateStats();
1115
1116     return count;
1117 }
1118
1119 void
1120 MediaDevice::purgeEmptyItems( MediaItem *root )
1121 {
1122     MediaItem *it = 0;
1123     if( root )
1124     {
1125         it = static_cast<MediaItem *>(root->firstChild());
1126     }
1127     else
1128     {
1129         it = static_cast<MediaItem *>(m_view->firstChild());
1130     }
1131
1132     MediaItem *next = 0;
1133     for( ; it; it=next )
1134     {
1135         next = static_cast<MediaItem *>(it->nextSibling());
1136         purgeEmptyItems( it );
1137         if( it->childCount() == 0 &&
1138                 (it->type() == MediaItem::ARTIST ||
1139                  it->type() == MediaItem::ALBUM ||
1140                  it->type() == MediaItem::PODCASTCHANNEL) )
1141             delete it;
1142     }
1143 }
1144
1145 bool
1146 MediaDevice::isPlayable( const MetaBundle &bundle )
1147 {
1148     if( supportedFiletypes().isEmpty() )
1149         return true;
1150
1151     QString type = bundle.url().path().section( ".", -1 ).toLower();
1152     return supportedFiletypes().contains( type );
1153 }
1154
1155 bool
1156 MediaDevice::isPreferredFormat( const MetaBundle &bundle )
1157 {
1158     if( supportedFiletypes().isEmpty() )
1159         return true;
1160
1161     QString type = bundle.url().path().section( ".", -1 ).toLower();
1162     return ( type == supportedFiletypes().first() );
1163 }
1164
1165 #include "MediaDevice.moc"
1166