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();
}