void TestAmazonMetaFactory::testCreateAlbum() { QStringList list, list2; list << "id" << "name" << "description" << "artistID" << "price" << "coverUrl" << "ASIN"; list2 << "23" << "name" << "description" << "42" << "price" << "coverUrl" << "ASIN"; AmazonMetaFactory factory( "Amazontest" ); Meta::AlbumPtr albumPtr = factory.createAlbum( list ); Meta::AlbumPtr albumPtr2 = factory.createAlbum( list2 ); QVERIFY( albumPtr ); QVERIFY( albumPtr2 ); Meta::AmazonAlbum* amazonAlbum = dynamic_cast<Meta::AmazonAlbum*>( albumPtr.data() ); Meta::AmazonAlbum* amazonAlbum2 = dynamic_cast<Meta::AmazonAlbum*>( albumPtr2.data() ); QVERIFY( amazonAlbum ); QVERIFY( amazonAlbum2 ); QCOMPARE( amazonAlbum->id(), 0 ); QCOMPARE( amazonAlbum->name(), QString( "name" ) ); QCOMPARE( amazonAlbum->description(), QString( "description" ) ); QCOMPARE( amazonAlbum->artistId(), 0 ); QCOMPARE( amazonAlbum->price(), QString( "price" ) ); QCOMPARE( amazonAlbum->coverUrl(), QString( "coverUrl" ) ); QCOMPARE( amazonAlbum->asin(), QString( "ASIN" ) ); QCOMPARE( amazonAlbum2->id(), 23 ); QCOMPARE( amazonAlbum2->artistId(), 42 ); }
QPixmap SvgHandler::imageWithBorder( Meta::AlbumPtr album, int size, int borderWidth ) { const int imageSize = size - ( borderWidth * 2 ); const QString &loc = album->imageLocation( imageSize ).url(); const QString &key = !loc.isEmpty() ? loc : album->name(); return addBordersToPixmap( The::coverCache()->getCover( album, imageSize ), borderWidth, key ); }
Dynamic::TrackSet Dynamic::AlbumPlayBias::matchingTracks( const Meta::TrackList& playlist, int contextCount, int finalCount, Dynamic::TrackCollectionPtr universe ) const { Q_UNUSED( contextCount ); Q_UNUSED( finalCount ); if( playlist.isEmpty() ) // no track means we can't find any tracks in the same album return Dynamic::TrackSet( universe, false ); Meta::TrackPtr track = playlist.last(); Meta::AlbumPtr album = track->album(); if( !album ) // no album means we can't find any tracks in the same album return Dynamic::TrackSet( universe, false ); Meta::TrackList albumTracks = album->tracks(); if( ( albumTracks.count() <= 1 ) || // the album has only one track (or even less) so there can't be any other tracks in the same album ( m_follow != DontCare && sameTrack( track, albumTracks.last() ) ) ) // track is the last one and we want to find a later one. return Dynamic::TrackSet( universe, false ); // we assume that the album tracks are sorted by cd and track number which // is at least true for the SqlCollection TrackSet result( universe, false ); if( m_follow == DirectlyFollow ) { for( int i = 1; i < albumTracks.count(); i++ ) if( sameTrack( albumTracks[i-1], track ) ) result.unite( albumTracks[i] ); } else if( m_follow == Follow ) { bool found = false; for( int i = 0; i < albumTracks.count(); i++ ) { if( found ) result.unite( albumTracks[i] ); if( sameTrack( albumTracks[i], track ) ) found = true; } } else if( m_follow == DontCare ) { for( int i = 0; i < albumTracks.count(); i++ ) { if( !sameTrack( albumTracks[i], track ) ) result.unite( albumTracks[i] ); } } return result; }
Dynamic::TrackSet Dynamic::AlbumPlayBias::matchingTracks( int position, const Meta::TrackList& playlist, int contextCount, Dynamic::TrackCollectionPtr universe ) const { Q_UNUSED( contextCount ); if( position < 1 || position >= playlist.count() ) return Dynamic::TrackSet( universe, false ); Meta::TrackPtr track = playlist[position-1]; Meta::AlbumPtr album = track->album(); if( !album ) return Dynamic::TrackSet( universe, false ); Meta::TrackList albumTracks = album->tracks(); if( albumTracks.count() == 1 || (track == albumTracks.last() && m_follow != DontCare) ) return Dynamic::TrackSet( universe, false ); // we assume that the album tracks are sorted by cd and track number which // is at least true for the SqlCollection TrackSet result( universe, false ); if( m_follow == DirectlyFollow ) { for( int i = 1; i < albumTracks.count(); i++ ) if( albumTracks[i-1] == track ) result.unite( albumTracks[i] ); } else if( m_follow == Follow ) { bool found = false; for( int i = 0; i < albumTracks.count(); i++ ) { if( found ) result.unite( albumTracks[i] ); if( albumTracks[i] == track ) found = true; } } else if( m_follow == DontCare ) { for( int i = 0; i < albumTracks.count(); i++ ) { if( albumTracks[i] != track ) result.unite( albumTracks[i] ); } } return result; }
QPixmap PlainImageLoader::GetPixmap(Meta::AlbumPtr iAlbum) { QPixmap pixmap; if ( iAlbum->hasImage() ) { pixmap = QPixmap::fromImage(iAlbum->image()); } else { pixmap = QPixmap( KStandardDirs::locate( "data", "amarok/images/blingdefaultcover.png" ) ); } return pixmap; }
bool Dynamic::AlbumPlayBias::trackMatches( int position, const Meta::TrackList& playlist, int contextCount ) const { Q_UNUSED( contextCount ); if( position <= 0 || playlist.count() <= position ) return true; Meta::TrackPtr track = playlist[position-1]; Meta::AlbumPtr album = track->album(); Meta::TrackPtr currentTrack = playlist[position]; Meta::AlbumPtr currentAlbum = currentTrack->album(); if( !album || album->tracks().isEmpty() ) return false; Meta::TrackList albumTracks = album->tracks(); if( sameTrack( track, albumTracks.last() ) && m_follow != DontCare ) return false; // we assume that the album tracks are sorted by cd and track number which // is at least true for the SqlCollection if( m_follow == DirectlyFollow ) { for( int i = 1; i < albumTracks.count(); i++ ) if( sameTrack( albumTracks[i-1], track ) ) return sameTrack( albumTracks[i], currentTrack ); return false; } else if( m_follow == Follow ) { bool found = false; for( int i = 0; i < albumTracks.count(); i++ ) { if( found && sameTrack( albumTracks[i], currentTrack ) ) return true; if( sameTrack( albumTracks[i], track ) ) found = true; } return false; } else if( m_follow == DontCare ) { return album == currentAlbum; } return false; }
void CurrentTrack::coverDropped( const QPixmap &cover ) { DEBUG_BLOCK Meta::TrackPtr track = The::engineController()->currentTrack(); if( !track ) return; Meta::AlbumPtr album = track->album(); if( !album ) return; if ( !cover.isNull() ) album->setImage( cover.toImage() ); }
AmarokUrl NavigationUrlGenerator::urlFromAlbum( Meta::AlbumPtr album ) { AmarokUrl url; QScopedPointer<Capabilities::BookmarkThisCapability> btc( album->create<Capabilities::BookmarkThisCapability>() ); if( btc ) { if( btc->isBookmarkable() ) { QString albumName = album->prettyName(); url.setCommand( "navigate" ); QString path = btc->browserName(); if ( !btc->collectionName().isEmpty() ) path += ( '/' + btc->collectionName() ); url.setPath( path ); QString filter; if ( btc->simpleFiltering() ) { filter = "\"" + albumName + "\""; } else { url.setArg( "levels", "album" ); QString artistName; if ( album->albumArtist() ) artistName = album->albumArtist()->prettyName(); filter = "album:\"" + albumName + "\""; if ( !artistName.isEmpty() ) filter += ( " AND artist:\"" + artistName + "\"" ); } url.setArg( "filter", filter ); if ( !btc->collectionName().isEmpty() ) url.setName( i18n( "Album \"%1\" from %2", albumName, btc->collectionName() ) ); else url.setName( i18n( "Album \"%1\"", albumName ) ); } } //debug() << "got url: " << url.url(); return url; }
CoverFetchPayload::CoverFetchPayload( const Meta::AlbumPtr album, CoverFetchPayload::Type type, CoverFetch::Source src ) : m_src( src ) , m_album( album ) , m_method( ( type == Search ) ? QString( "album.search" ) : album && album->hasAlbumArtist() ? QString( "album.getinfo" ) : QString( "album.search" ) ) , m_type( type ) { }
void CurrentEngine::metadataChanged( Meta::AlbumPtr album ) { QImage cover = album->image( m_coverWidth ); qint64 coverCacheKey = cover.cacheKey(); if( m_coverCacheKey != coverCacheKey ) { m_coverCacheKey = coverCacheKey; setData( "current", "albumart", cover ); } }
int AmazonParser::addAlbumToCollection( const QString &albumTitle, const QString &description, const QString &artistID, const QString &price, const QString &imgUrl, const QString &albumAsin, const bool isCompilation ) { QStringList results; QString albumID; debug() << albumAsin; if( !m_collection->albumIDMap().contains( albumAsin ) ) // we have a new album here { // id, name, description, artistID albumID.setNum( m_collection->albumIDMap().size() + 1 ); results << albumID << albumTitle << description << artistID << price << imgUrl << albumAsin; Meta::AlbumPtr newAlbum = m_factory->createAlbum( results ); newAlbum->setCompilation( isCompilation ); m_collection->addAlbum( newAlbum ); m_collection->albumIDMap().insert( albumAsin, albumID.toInt() ); } else // album is known, but we might need to update it { int id; id = m_collection->albumIDMap().value( albumAsin ); if( !price.isEmpty() ) { dynamic_cast<Meta::AmazonAlbum*>( m_collection->albumById( id ).data() )->setPrice( price ); } if( !imgUrl.isEmpty() ) { dynamic_cast<Meta::AmazonAlbum*>( m_collection->albumById( id ).data() )->setCoverUrl( imgUrl ); } } // return album ID return m_collection->albumIDMap().value( albumAsin ); }
void ScrobblerAdapter::copyTrackMetadata( lastfm::MutableTrack &to, const Meta::TrackPtr &track ) { to.setTitle( track->name() ); QString artistOrComposer; Meta::ComposerPtr composer = track->composer(); if( m_config->scrobbleComposer() && composer ) artistOrComposer = composer->name(); Meta::ArtistPtr artist = track->artist(); if( artistOrComposer.isEmpty() && artist ) artistOrComposer = artist->name(); to.setArtist( artistOrComposer ); Meta::AlbumPtr album = track->album(); Meta::ArtistPtr albumArtist; if( album ) { to.setAlbum( album->name() ); albumArtist = album->hasAlbumArtist() ? album->albumArtist() : Meta::ArtistPtr(); } if( albumArtist ) to.setAlbumArtist( albumArtist->name() ); to.setDuration( track->length() / 1000 ); if( track->trackNumber() >= 0 ) to.setTrackNumber( track->trackNumber() ); lastfm::Track::Source source = lastfm::Track::Player; if( track->type() == "stream/lastfm" ) source = lastfm::Track::LastFmRadio; else if( track->type().startsWith( "stream" ) ) source = lastfm::Track::NonPersonalisedBroadcast; else if( track->collection() && track->collection()->collectionId() != "localCollection" ) source = lastfm::Track::MediaDevice; to.setSource( source ); }
void CurrentEngine::update( Meta::AlbumPtr album ) { if( !m_requested.value( QLatin1String("albums") ) ) return; DEBUG_BLOCK m_lastQueryMaker = 0; Meta::TrackPtr track = The::engineController()->currentTrack(); if( !album ) return; Meta::ArtistPtr artist = track->artist(); // Prefer track artist to album artist BUG: 266682 if( !artist ) artist = album->albumArtist(); if( artist && !artist->name().isEmpty() ) { m_albums.clear(); m_albumData.clear(); m_albumData[ QLatin1String("currentTrack") ] = qVariantFromValue( track ); m_albumData[ QLatin1String("headerText") ] = QVariant( i18n( "Albums by %1", artist->name() ) ); // -- search the collection for albums with the same artist Collections::QueryMaker *qm = CollectionManager::instance()->queryMaker(); qm->setAutoDelete( true ); qm->addFilter( Meta::valArtist, artist->name(), true, true ); qm->setAlbumQueryMode( Collections::QueryMaker::AllAlbums ); qm->setQueryType( Collections::QueryMaker::Album ); connect( qm, SIGNAL(newResultReady( Meta::AlbumList)), SLOT(resultReady( Meta::AlbumList)), Qt::QueuedConnection ); connect( qm, SIGNAL(queryDone()), SLOT(setupAlbumsData()) ); m_lastQueryMaker = qm; qm->run(); } else { removeAllData( QLatin1String("albums") ); setData( QLatin1String("albums"), QLatin1String("headerText"), i18nc( "Header text for current album applet", "Albums" ) ); } }
QString TrackOrganizer::buildDestination(const QString& format, const Meta::TrackPtr& track) const { // get hold of the shared pointers Meta::AlbumPtr album = track->album(); Meta::ArtistPtr artist = track->artist(); Meta::ComposerPtr composer = track->composer(); Meta::ArtistPtr albumArtist = album ? album->albumArtist() : Meta::ArtistPtr(); Meta::GenrePtr genre = track->genre(); Meta::YearPtr year = track->year(); bool isCompilation = album && album->isCompilation(); QMap<QString, QString> args; QString strArtist = artist ? artist->name() : QString(); QString strAlbumArtist = isCompilation ? i18n( "Various Artists" ) : ( albumArtist ? albumArtist->name() : strArtist ); args["theartist"] = strArtist; args["thealbumartist"] = strAlbumArtist; if( m_postfixThe ) { Amarok::manipulateThe( strArtist, true ); Amarok::manipulateThe( strAlbumArtist, true ); } if ( track->trackNumber() ) { QString trackNum = QString("%1").arg( track->trackNumber(), 2, 10, QChar('0') ); args["track"] = trackNum; } args["title"] = track->name(); args["artist"] = strArtist; args["composer"] = composer ? composer->name() : QString(); // if year == 0 then we don't want include it QString strYear = year ? year->name() : QString(); args["year"] = strYear.localeAwareCompare( "0" ) == 0 ? QString() : strYear; args["album"] = track->album() ? track->album()->name() : QString(); args["albumartist"] = strAlbumArtist; args["comment"] = track->comment(); args["genre"] = genre ? genre->name() : QString(); if( m_targetFileExtension.isEmpty() ) args["filetype"] = track->type(); else args["filetype"] = m_targetFileExtension; QString strFolder = QFileInfo( track->playableUrl().toLocalFile() ).path(); strFolder = strFolder.mid( commonPrefixLength( m_folderPrefix, strFolder ) ); args["folder"] = strFolder; args["initial"] = strAlbumArtist.mid( 0, 1 ).toUpper(); //artists starting with The are already handled above if( track->discNumber() ) args["discnumber"] = QString::number( track->discNumber() ); args["collectionroot"] = m_folderPrefix; // some additional properties not supported by organize dialog. args["rating"] = track->statistics()->rating(); args["filesize"] = track->filesize(); args["length"] = track->length() / 1000; // Fill up default empty values for StringX formater // TODO make this values changeable by user args["default_album"] = i18n( "Unknown album" ); args["default_albumartist"] = i18n( "Unknown artist" ); args["default_artist"] = args["albumartist"]; args["default_thealbumartist"] = args["albumartist"]; args["default_theartist"] = args["albumartist"]; args["default_comment"] = i18n( "No comments" ); args["default_composer"] = i18n( "Unknown composer" ); args["default_discnumber"] = i18n( "Unknown disc number" ); args["default_genre"] = i18n( "Unknown genre" ); args["default_title"] = i18n( "Unknown title" ); args["default_year"] = i18n( "Unknown year" ); foreach( const QString &key, args.keys() ) if( key != "collectionroot" && key != "folder" ) args[key] = args[key].replace( '/', '-' ); Amarok::QStringx formatx( format ); QString result = formatx.namedOptArgs( args ); return cleanPath( result ); }
void CurrentTrack::setupLayoutActions( Meta::TrackPtr track ) { if( !track ) return; PERF_LOG( "Begin actions layout setup" ); //first, add any global CurrentTrackActions (iow, actions that are shown for all tracks) QList<QAction *> actions = The::globalCurrentTrackActions()->actions(); using namespace Capabilities; QScopedPointer<ActionsCapability> ac( track->create<ActionsCapability>() ); if( ac ) { QList<QAction*> trackActions = ac->actions(); // ensure that the actions get deleted afterwards foreach( QAction* action, trackActions ) { if( !action->parent() ) action->setParent( this ); actions << action; } } QScopedPointer<BookmarkThisCapability> btc( track->create<BookmarkThisCapability>() ); if( btc && btc->bookmarkAction() ) { actions << btc->bookmarkAction(); } if( m_showEditTrackDetailsAction && track->editor() ) { QAction *editAction = new QAction( KIcon("media-track-edit-amarok"), i18n("Edit Track Details"), this ); connect( editAction, SIGNAL(triggered()), SLOT(editTrack()) ); m_customActions << editAction; } if( track->has<FindInSourceCapability>() ) { if( !m_findInSourceSignalMapper ) { m_findInSourceSignalMapper = new QSignalMapper( this ); connect( m_findInSourceSignalMapper, SIGNAL(mapped(QString)), SLOT(findInSource(QString)) ); } Meta::AlbumPtr album = track->album(); Meta::ArtistPtr artist = track->artist(); Meta::ComposerPtr composer = track->composer(); Meta::GenrePtr genre = track->genre(); Meta::YearPtr year = track->year(); QAction *act( 0 ); if( album && !album->name().isEmpty() ) { act = new QAction( KIcon("current-track-amarok"), i18n("Show Album in Media Sources"), this ); connect( act, SIGNAL(triggered()), m_findInSourceSignalMapper, SLOT(map()) ); m_findInSourceSignalMapper->setMapping( act, QLatin1String("album") ); m_customActions << act; } if( artist && !artist->name().isEmpty() ) { act = new QAction( KIcon("filename-artist-amarok"), i18n("Show Artist in Media Sources"), this ); connect( act, SIGNAL(triggered()), m_findInSourceSignalMapper, SLOT(map()) ); m_findInSourceSignalMapper->setMapping( act, QLatin1String("artist") ); m_customActions << act; KPluginInfo::List services = The::pluginManager()->plugins( QLatin1String("Service") ); foreach( const KPluginInfo &service, services ) { if( service.pluginName() == QLatin1String("amarok_service_amazonstore") ) { if( service.isPluginEnabled() ) { act = new QAction( KIcon("view-services-amazon-amarok"), i18n("Search for Artist in the MP3 Music Store"), this ); connect( act, SIGNAL(triggered()), this, SLOT(findInStore()) ); m_customActions << act; } break; } } } if( composer && !composer->name().isEmpty() && (composer->name() != i18n("Unknown Composer")) ) { act = new QAction( KIcon("filename-composer-amarok"), i18n("Show Composer in Media Sources"), this ); connect( act, SIGNAL(triggered()), m_findInSourceSignalMapper, SLOT(map()) ); m_findInSourceSignalMapper->setMapping( act, QLatin1String("composer") ); m_customActions << act; } if( genre && !genre->name().isEmpty() ) { act = new QAction( KIcon("filename-genre-amarok"), i18n("Show Genre in Media Sources"), this ); connect( act, SIGNAL(triggered()), m_findInSourceSignalMapper, SLOT(map()) ); m_findInSourceSignalMapper->setMapping( act, QLatin1String("genre") ); m_customActions << act; } if( year && !year->name().isEmpty() ) { act = new QAction( KIcon("filename-year-amarok"), i18n("Show Year in Media Sources"), this ); connect( act, SIGNAL(triggered()), m_findInSourceSignalMapper, SLOT(map()) ); m_findInSourceSignalMapper->setMapping( act, QLatin1String("year") ); m_customActions << act; } }
void addMockTrack( Collections::CollectionTestImpl *coll, const QString &trackName, const QString &artistName, const QString &albumName ) { Meta::MockTrack *track = new Meta::MockTrack(); ::testing::Mock::AllowLeak( track ); Meta::TrackPtr trackPtr( track ); EXPECT_CALL( *track, name() ).Times( AnyNumber() ).WillRepeatedly( Return( trackName ) ); EXPECT_CALL( *track, prettyName() ).Times( AnyNumber() ).WillRepeatedly( Return( trackName ) ); EXPECT_CALL( *track, uidUrl() ).Times( AnyNumber() ).WillRepeatedly( Return( trackName + '_' + artistName + '_' + albumName ) ); EXPECT_CALL( *track, playableUrl() ).Times( AnyNumber() ).WillRepeatedly( Return( KUrl( '/' + track->uidUrl() ) ) ); EXPECT_CALL( *track, composer() ).Times( AnyNumber() ).WillRepeatedly( Return( Meta::ComposerPtr() ) ); EXPECT_CALL( *track, genre() ).Times( AnyNumber() ).WillRepeatedly( Return( Meta::GenrePtr() ) ); EXPECT_CALL( *track, year() ).Times( AnyNumber() ).WillRepeatedly( Return( Meta::YearPtr() ) ); coll->mc->addTrack( trackPtr ); Meta::AlbumPtr albumPtr = coll->mc->albumMap().value( albumName, QString() /* no album artist */ ); Meta::MockAlbum *album; Meta::TrackList albumTracks; if( albumPtr ) { album = dynamic_cast<Meta::MockAlbum*>( albumPtr.data() ); if( !album ) { QFAIL( "expected a Meta::MockAlbum" ); return; } albumTracks = albumPtr->tracks(); } else { album = new Meta::MockAlbum(); ::testing::Mock::AllowLeak( album ); albumPtr = Meta::AlbumPtr( album ); EXPECT_CALL( *album, name() ).Times( AnyNumber() ).WillRepeatedly( Return( albumName ) ); EXPECT_CALL( *album, prettyName() ).Times( AnyNumber() ).WillRepeatedly( Return( albumName ) ); EXPECT_CALL( *album, hasAlbumArtist() ).Times( AnyNumber() ).WillRepeatedly( Return( false ) ); EXPECT_CALL( *album, isCompilation() ).Times( AnyNumber() ).WillRepeatedly( Return( false ) ); //inconsistent coll->mc->addAlbum( albumPtr ); } albumTracks << trackPtr; EXPECT_CALL( *album, tracks() ).Times( AnyNumber() ).WillRepeatedly( Return( albumTracks ) ); EXPECT_CALL( *track, album() ).Times( AnyNumber() ).WillRepeatedly( Return( albumPtr ) ); Meta::ArtistPtr artistPtr = coll->mc->artistMap().value( artistName ); Meta::MockArtist *artist; Meta::TrackList artistTracks; if( artistPtr ) { artist = dynamic_cast<Meta::MockArtist*>( artistPtr.data() ); if( !artist ) { QFAIL( "expected a Meta::MockArtist" ); return; } artistTracks = artistPtr->tracks(); } else { artist = new Meta::MockArtist(); ::testing::Mock::AllowLeak( artist ); artistPtr = Meta::ArtistPtr( artist ); EXPECT_CALL( *artist, name() ).Times( AnyNumber() ).WillRepeatedly( Return( artistName ) ); EXPECT_CALL( *artist, prettyName() ).Times( AnyNumber() ).WillRepeatedly( Return( artistName ) ); coll->mc->addArtist( artistPtr ); } artistTracks << trackPtr; EXPECT_CALL( *artist, tracks() ).Times( AnyNumber() ).WillRepeatedly( Return( artistTracks ) ); EXPECT_CALL( *track, artist() ).Times( AnyNumber() ).WillRepeatedly( Return( artistPtr ) ); EXPECT_CALL( *album, albumArtist() ).Times( AnyNumber() ).WillRepeatedly( Return( artistPtr ) ); }
foreach( Meta::AlbumPtr album, albums ) { m_albums << album->name(); }