2018-02-27 18:06:05 +01:00
|
|
|
/*
|
|
|
|
* Strawberry Music Player
|
|
|
|
* This file was part of Clementine.
|
|
|
|
* Copyright 2012, David Sansome <me@davidsansome.com>
|
2018-12-29 03:25:21 +01:00
|
|
|
* Copyright 2012, 2014, John Maguire <john.maguire@gmail.com>
|
2021-03-20 21:14:47 +01:00
|
|
|
* Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
|
2018-02-27 18:06:05 +01:00
|
|
|
*
|
|
|
|
* Strawberry is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Strawberry is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with Strawberry. If not, see <http://www.gnu.org/licenses/>.
|
2018-08-09 18:10:03 +02:00
|
|
|
*
|
2018-02-27 18:06:05 +01:00
|
|
|
*/
|
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
#include "config.h"
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
#include "application.h"
|
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
#include <functional>
|
2021-06-20 19:04:08 +02:00
|
|
|
#include <chrono>
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
#include <QObject>
|
|
|
|
#include <QThread>
|
|
|
|
#include <QString>
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
#include "core/lazy.h"
|
|
|
|
#include "core/tagreaderclient.h"
|
2020-02-08 03:40:30 +01:00
|
|
|
#include "core/logging.h"
|
2018-05-01 00:41:33 +02:00
|
|
|
|
|
|
|
#include "database.h"
|
|
|
|
#include "taskmanager.h"
|
|
|
|
#include "player.h"
|
|
|
|
|
2019-11-03 19:53:08 +01:00
|
|
|
#include "engine/devicefinders.h"
|
2018-09-20 17:36:23 +02:00
|
|
|
#ifndef Q_OS_WIN
|
|
|
|
# include "device/devicemanager.h"
|
|
|
|
#endif
|
2018-02-27 18:06:05 +01:00
|
|
|
#include "collection/collection.h"
|
|
|
|
#include "playlist/playlistbackend.h"
|
|
|
|
#include "playlist/playlistmanager.h"
|
|
|
|
#include "covermanager/albumcoverloader.h"
|
|
|
|
#include "covermanager/coverproviders.h"
|
2019-07-07 21:14:24 +02:00
|
|
|
#include "covermanager/currentalbumcoverloader.h"
|
2018-12-15 00:43:50 +01:00
|
|
|
#include "covermanager/lastfmcoverprovider.h"
|
2018-02-27 18:06:05 +01:00
|
|
|
#include "covermanager/discogscoverprovider.h"
|
|
|
|
#include "covermanager/musicbrainzcoverprovider.h"
|
2019-04-14 02:54:40 +02:00
|
|
|
#include "covermanager/deezercoverprovider.h"
|
2020-05-08 20:14:16 +02:00
|
|
|
#include "covermanager/musixmatchcoverprovider.h"
|
2020-05-09 01:48:08 +02:00
|
|
|
#include "covermanager/spotifycoverprovider.h"
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-08-29 21:42:24 +02:00
|
|
|
#include "lyrics/lyricsproviders.h"
|
2020-05-08 18:35:36 +02:00
|
|
|
#include "lyrics/geniuslyricsprovider.h"
|
2019-08-12 18:11:01 +02:00
|
|
|
#include "lyrics/ovhlyricsprovider.h"
|
2019-08-12 22:06:01 +02:00
|
|
|
#include "lyrics/lololyricsprovider.h"
|
2020-05-08 18:35:36 +02:00
|
|
|
#include "lyrics/musixmatchlyricsprovider.h"
|
|
|
|
#include "lyrics/chartlyricsprovider.h"
|
2023-03-22 23:36:15 +01:00
|
|
|
#include "lyrics/lyricscomlyricsprovider.h"
|
2018-08-29 21:42:24 +02:00
|
|
|
|
2019-04-18 15:03:01 +02:00
|
|
|
#include "scrobbler/audioscrobbler.h"
|
2020-08-30 18:09:13 +02:00
|
|
|
#include "scrobbler/lastfmimport.h"
|
2019-04-18 15:03:01 +02:00
|
|
|
|
2018-10-23 23:25:02 +02:00
|
|
|
#include "internet/internetservices.h"
|
2018-08-09 18:10:03 +02:00
|
|
|
|
2019-06-17 23:54:24 +02:00
|
|
|
#ifdef HAVE_SUBSONIC
|
|
|
|
# include "subsonic/subsonicservice.h"
|
|
|
|
#endif
|
|
|
|
|
2020-04-13 19:04:06 +02:00
|
|
|
#ifdef HAVE_TIDAL
|
|
|
|
# include "tidal/tidalservice.h"
|
|
|
|
# include "covermanager/tidalcoverprovider.h"
|
|
|
|
#endif
|
|
|
|
|
2020-09-17 17:50:17 +02:00
|
|
|
#ifdef HAVE_QOBUZ
|
|
|
|
# include "qobuz/qobuzservice.h"
|
|
|
|
# include "covermanager/qobuzcoverprovider.h"
|
|
|
|
#endif
|
|
|
|
|
2019-04-18 15:03:01 +02:00
|
|
|
#ifdef HAVE_MOODBAR
|
|
|
|
# include "moodbar/moodbarcontroller.h"
|
|
|
|
# include "moodbar/moodbarloader.h"
|
|
|
|
#endif
|
2018-12-23 18:54:27 +01:00
|
|
|
|
2021-07-11 01:02:53 +02:00
|
|
|
#include "radios/radioservices.h"
|
|
|
|
#include "radios/radiobackend.h"
|
|
|
|
|
2021-06-20 19:04:08 +02:00
|
|
|
using namespace std::chrono_literals;
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
class ApplicationImpl {
|
|
|
|
public:
|
2019-04-08 18:46:11 +02:00
|
|
|
explicit ApplicationImpl(Application *app) :
|
2022-06-20 23:51:44 +02:00
|
|
|
tag_reader_client_([app]() {
|
2018-02-27 18:06:05 +01:00
|
|
|
TagReaderClient *client = new TagReaderClient(app);
|
|
|
|
app->MoveToNewThread(client);
|
|
|
|
client->Start();
|
|
|
|
return client;
|
|
|
|
}),
|
2022-06-20 23:51:44 +02:00
|
|
|
database_([app]() {
|
2018-02-27 18:06:05 +01:00
|
|
|
Database *db = new Database(app, app);
|
|
|
|
app->MoveToNewThread(db);
|
2021-06-20 19:04:08 +02:00
|
|
|
QTimer::singleShot(30s, db, &Database::DoBackup);
|
2018-02-27 18:06:05 +01:00
|
|
|
return db;
|
2018-08-29 21:42:24 +02:00
|
|
|
}),
|
2022-06-20 23:51:44 +02:00
|
|
|
task_manager_([app]() { return new TaskManager(app); }),
|
|
|
|
player_([app]() { return new Player(app, app); }),
|
|
|
|
device_finders_([app]() { return new DeviceFinders(app); }),
|
2018-09-20 17:36:23 +02:00
|
|
|
#ifndef Q_OS_WIN
|
2022-06-20 23:51:44 +02:00
|
|
|
device_manager_([app]() { return new DeviceManager(app, app); }),
|
2018-09-20 17:36:23 +02:00
|
|
|
#endif
|
2022-06-20 23:51:44 +02:00
|
|
|
collection_([app]() { return new SCollection(app, app); }),
|
|
|
|
playlist_backend_([this, app]() {
|
2018-02-27 18:06:05 +01:00
|
|
|
PlaylistBackend *backend = new PlaylistBackend(app, app);
|
|
|
|
app->MoveToThread(backend, database_->thread());
|
|
|
|
return backend;
|
|
|
|
}),
|
2022-06-20 23:51:44 +02:00
|
|
|
playlist_manager_([app]() { return new PlaylistManager(app); }),
|
|
|
|
cover_providers_([app]() {
|
2018-02-27 18:06:05 +01:00
|
|
|
CoverProviders *cover_providers = new CoverProviders(app);
|
|
|
|
// Initialize the repository of cover providers.
|
2021-08-12 23:00:10 +02:00
|
|
|
cover_providers->AddProvider(new LastFmCoverProvider(app, cover_providers->network(), app));
|
|
|
|
cover_providers->AddProvider(new MusicbrainzCoverProvider(app, cover_providers->network(), app));
|
|
|
|
cover_providers->AddProvider(new DiscogsCoverProvider(app, cover_providers->network(), app));
|
|
|
|
cover_providers->AddProvider(new DeezerCoverProvider(app, cover_providers->network(), app));
|
|
|
|
cover_providers->AddProvider(new MusixmatchCoverProvider(app, cover_providers->network(), app));
|
|
|
|
cover_providers->AddProvider(new SpotifyCoverProvider(app, cover_providers->network(), app));
|
2020-04-13 19:04:06 +02:00
|
|
|
#ifdef HAVE_TIDAL
|
2021-08-12 23:00:10 +02:00
|
|
|
cover_providers->AddProvider(new TidalCoverProvider(app, cover_providers->network(), app));
|
2020-09-17 17:50:17 +02:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_QOBUZ
|
2021-08-12 23:00:10 +02:00
|
|
|
cover_providers->AddProvider(new QobuzCoverProvider(app, cover_providers->network(), app));
|
2020-04-13 19:04:06 +02:00
|
|
|
#endif
|
2020-05-09 01:48:08 +02:00
|
|
|
cover_providers->ReloadSettings();
|
2018-02-27 18:06:05 +01:00
|
|
|
return cover_providers;
|
|
|
|
}),
|
2022-06-20 23:51:44 +02:00
|
|
|
album_cover_loader_([app]() {
|
2018-02-27 18:06:05 +01:00
|
|
|
AlbumCoverLoader *loader = new AlbumCoverLoader(app);
|
|
|
|
app->MoveToNewThread(loader);
|
|
|
|
return loader;
|
|
|
|
}),
|
2022-06-20 23:51:44 +02:00
|
|
|
current_albumcover_loader_([app]() { return new CurrentAlbumCoverLoader(app, app); }),
|
|
|
|
lyrics_providers_([app]() {
|
2018-08-29 21:42:24 +02:00
|
|
|
LyricsProviders *lyrics_providers = new LyricsProviders(app);
|
2020-05-09 01:48:08 +02:00
|
|
|
// Initialize the repository of lyrics providers.
|
2021-08-12 23:00:10 +02:00
|
|
|
lyrics_providers->AddProvider(new GeniusLyricsProvider(lyrics_providers->network(), app));
|
|
|
|
lyrics_providers->AddProvider(new OVHLyricsProvider(lyrics_providers->network(), app));
|
|
|
|
lyrics_providers->AddProvider(new LoloLyricsProvider(lyrics_providers->network(), app));
|
|
|
|
lyrics_providers->AddProvider(new MusixmatchLyricsProvider(lyrics_providers->network(), app));
|
|
|
|
lyrics_providers->AddProvider(new ChartLyricsProvider(lyrics_providers->network(), app));
|
2023-03-22 23:36:15 +01:00
|
|
|
lyrics_providers->AddProvider(new LyricsComLyricsProvider(lyrics_providers->network(), app));
|
2020-05-08 18:35:36 +02:00
|
|
|
lyrics_providers->ReloadSettings();
|
2018-10-14 00:08:33 +02:00
|
|
|
return lyrics_providers;
|
|
|
|
}),
|
2022-06-20 23:51:44 +02:00
|
|
|
internet_services_([app]() {
|
2018-10-23 23:25:02 +02:00
|
|
|
InternetServices *internet_services = new InternetServices(app);
|
2019-06-17 23:54:24 +02:00
|
|
|
#ifdef HAVE_SUBSONIC
|
|
|
|
internet_services->AddService(new SubsonicService(app, internet_services));
|
2020-04-13 19:04:06 +02:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_TIDAL
|
|
|
|
internet_services->AddService(new TidalService(app, internet_services));
|
2020-09-17 17:50:17 +02:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_QOBUZ
|
|
|
|
internet_services->AddService(new QobuzService(app, internet_services));
|
2018-10-23 23:25:02 +02:00
|
|
|
#endif
|
|
|
|
return internet_services;
|
|
|
|
}),
|
2022-06-20 23:51:44 +02:00
|
|
|
radio_services_([app]() { return new RadioServices(app, app); }),
|
|
|
|
scrobbler_([app]() { return new AudioScrobbler(app, app); }),
|
2019-04-18 15:03:01 +02:00
|
|
|
#ifdef HAVE_MOODBAR
|
2022-06-20 23:51:44 +02:00
|
|
|
moodbar_loader_([app]() { return new MoodbarLoader(app, app); }),
|
|
|
|
moodbar_controller_([app]() { return new MoodbarController(app, app); }),
|
2019-04-18 15:03:01 +02:00
|
|
|
#endif
|
2022-06-20 23:51:44 +02:00
|
|
|
lastfm_import_([app]() { return new LastFMImport(app); })
|
2018-10-14 00:08:33 +02:00
|
|
|
{}
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
Lazy<TagReaderClient> tag_reader_client_;
|
|
|
|
Lazy<Database> database_;
|
|
|
|
Lazy<TaskManager> task_manager_;
|
|
|
|
Lazy<Player> player_;
|
2019-11-03 19:53:08 +01:00
|
|
|
Lazy<DeviceFinders> device_finders_;
|
2018-09-20 17:36:23 +02:00
|
|
|
#ifndef Q_OS_WIN
|
2018-02-27 18:06:05 +01:00
|
|
|
Lazy<DeviceManager> device_manager_;
|
2018-09-20 17:36:23 +02:00
|
|
|
#endif
|
2018-07-01 22:26:46 +02:00
|
|
|
Lazy<SCollection> collection_;
|
2018-02-27 18:06:05 +01:00
|
|
|
Lazy<PlaylistBackend> playlist_backend_;
|
|
|
|
Lazy<PlaylistManager> playlist_manager_;
|
|
|
|
Lazy<CoverProviders> cover_providers_;
|
|
|
|
Lazy<AlbumCoverLoader> album_cover_loader_;
|
2019-07-07 21:14:24 +02:00
|
|
|
Lazy<CurrentAlbumCoverLoader> current_albumcover_loader_;
|
2018-10-14 00:08:33 +02:00
|
|
|
Lazy<LyricsProviders> lyrics_providers_;
|
2018-10-23 23:25:02 +02:00
|
|
|
Lazy<InternetServices> internet_services_;
|
2021-07-11 01:02:53 +02:00
|
|
|
Lazy<RadioServices> radio_services_;
|
2018-12-23 18:54:27 +01:00
|
|
|
Lazy<AudioScrobbler> scrobbler_;
|
2019-04-18 15:03:01 +02:00
|
|
|
#ifdef HAVE_MOODBAR
|
|
|
|
Lazy<MoodbarLoader> moodbar_loader_;
|
|
|
|
Lazy<MoodbarController> moodbar_controller_;
|
|
|
|
#endif
|
2021-07-11 01:02:53 +02:00
|
|
|
Lazy<LastFMImport> lastfm_import_;
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
Application::Application(QObject *parent)
|
|
|
|
: QObject(parent), p_(new ApplicationImpl(this)) {
|
|
|
|
|
2019-11-03 19:53:08 +01:00
|
|
|
device_finders()->Init();
|
2018-02-27 18:06:05 +01:00
|
|
|
collection()->Init();
|
|
|
|
tag_reader_client();
|
|
|
|
|
2021-09-09 21:45:46 +02:00
|
|
|
QObject::connect(database(), &Database::Error, this, &Application::ErrorAdded);
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Application::~Application() {
|
|
|
|
|
|
|
|
// It's important that the device manager is deleted before the database.
|
2018-05-01 00:41:33 +02:00
|
|
|
// Deleting the database deletes all objects that have been created in its thread, including some device collection backends.
|
2018-09-20 17:36:23 +02:00
|
|
|
#ifndef Q_OS_WIN
|
2018-02-27 18:06:05 +01:00
|
|
|
p_->device_manager_.reset();
|
2018-09-20 17:36:23 +02:00
|
|
|
#endif
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
for (QThread *thread : threads_) {
|
|
|
|
thread->quit();
|
|
|
|
}
|
|
|
|
|
|
|
|
for (QThread *thread : threads_) {
|
|
|
|
thread->wait();
|
2019-07-24 19:16:51 +02:00
|
|
|
thread->deleteLater();
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
2019-07-24 19:16:51 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
2019-07-24 19:16:51 +02:00
|
|
|
QThread *Application::MoveToNewThread(QObject *object) {
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
QThread *thread = new QThread(this);
|
|
|
|
|
|
|
|
MoveToThread(object, thread);
|
|
|
|
|
|
|
|
thread->start();
|
|
|
|
threads_ << thread;
|
2019-07-24 19:16:51 +02:00
|
|
|
|
|
|
|
return thread;
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Application::MoveToThread(QObject *object, QThread *thread) {
|
|
|
|
object->setParent(nullptr);
|
|
|
|
object->moveToThread(thread);
|
2019-09-07 23:30:35 +02:00
|
|
|
qLog(Debug) << object << "moved to thread" << thread;
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
2019-07-24 19:16:51 +02:00
|
|
|
void Application::Exit() {
|
|
|
|
|
2019-07-24 23:29:09 +02:00
|
|
|
wait_for_exit_ << tag_reader_client()
|
|
|
|
<< collection()
|
2019-07-24 19:16:51 +02:00
|
|
|
<< playlist_backend()
|
2019-07-24 23:29:09 +02:00
|
|
|
<< album_cover_loader()
|
2019-07-24 19:34:33 +02:00
|
|
|
#ifndef Q_OS_WIN
|
2019-07-24 19:16:51 +02:00
|
|
|
<< device_manager()
|
2019-07-24 19:34:33 +02:00
|
|
|
#endif
|
2021-07-11 01:02:53 +02:00
|
|
|
<< internet_services()
|
|
|
|
<< radio_services()->radio_backend();
|
2019-07-24 19:16:51 +02:00
|
|
|
|
2021-01-26 16:48:04 +01:00
|
|
|
QObject::connect(tag_reader_client(), &TagReaderClient::ExitFinished, this, &Application::ExitReceived);
|
2019-07-24 23:29:09 +02:00
|
|
|
tag_reader_client()->ExitAsync();
|
|
|
|
|
2021-01-26 16:48:04 +01:00
|
|
|
QObject::connect(collection(), &SCollection::ExitFinished, this, &Application::ExitReceived);
|
2019-07-24 19:16:51 +02:00
|
|
|
collection()->Exit();
|
|
|
|
|
2021-01-26 16:48:04 +01:00
|
|
|
QObject::connect(playlist_backend(), &PlaylistBackend::ExitFinished, this, &Application::ExitReceived);
|
2019-07-24 19:16:51 +02:00
|
|
|
playlist_backend()->ExitAsync();
|
|
|
|
|
2021-01-26 16:48:04 +01:00
|
|
|
QObject::connect(album_cover_loader(), &AlbumCoverLoader::ExitFinished, this, &Application::ExitReceived);
|
2019-07-24 23:29:09 +02:00
|
|
|
album_cover_loader()->ExitAsync();
|
|
|
|
|
2019-07-24 19:34:33 +02:00
|
|
|
#ifndef Q_OS_WIN
|
2021-01-26 16:48:04 +01:00
|
|
|
QObject::connect(device_manager(), &DeviceManager::ExitFinished, this, &Application::ExitReceived);
|
2019-07-24 19:16:51 +02:00
|
|
|
device_manager()->Exit();
|
2019-07-24 19:34:33 +02:00
|
|
|
#endif
|
2019-07-24 19:16:51 +02:00
|
|
|
|
2021-01-26 16:48:04 +01:00
|
|
|
QObject::connect(internet_services(), &InternetServices::ExitFinished, this, &Application::ExitReceived);
|
2019-07-24 19:16:51 +02:00
|
|
|
internet_services()->Exit();
|
|
|
|
|
2021-07-11 01:02:53 +02:00
|
|
|
QObject::connect(radio_services()->radio_backend(), &RadioBackend::ExitFinished, this, &Application::ExitReceived);
|
|
|
|
radio_services()->radio_backend()->ExitAsync();
|
|
|
|
|
2019-07-24 19:16:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void Application::ExitReceived() {
|
|
|
|
|
2021-06-20 19:04:08 +02:00
|
|
|
QObject *obj = sender();
|
2021-01-26 16:48:04 +01:00
|
|
|
QObject::disconnect(obj, nullptr, this, nullptr);
|
2019-07-24 19:16:51 +02:00
|
|
|
|
2019-07-24 23:29:09 +02:00
|
|
|
qLog(Debug) << obj << "successfully exited.";
|
|
|
|
|
|
|
|
wait_for_exit_.removeAll(obj);
|
|
|
|
if (wait_for_exit_.isEmpty()) {
|
|
|
|
database()->Close();
|
2021-01-26 16:48:04 +01:00
|
|
|
QObject::connect(database(), &Database::ExitFinished, this, &Application::ExitFinished);
|
2019-07-24 23:29:09 +02:00
|
|
|
database()->ExitAsync();
|
|
|
|
}
|
2019-07-24 19:16:51 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2021-06-12 20:53:23 +02:00
|
|
|
void Application::AddError(const QString &message) { emit ErrorAdded(message); }
|
2018-02-27 18:06:05 +01:00
|
|
|
void Application::ReloadSettings() { emit SettingsChanged(); }
|
2018-10-14 00:08:33 +02:00
|
|
|
void Application::OpenSettingsDialogAtPage(SettingsDialog::Page page) { emit SettingsDialogRequested(page); }
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-10-14 00:08:33 +02:00
|
|
|
TagReaderClient *Application::tag_reader_client() const { return p_->tag_reader_client_.get(); }
|
2018-02-27 18:06:05 +01:00
|
|
|
Database *Application::database() const { return p_->database_.get(); }
|
2018-10-14 00:08:33 +02:00
|
|
|
TaskManager *Application::task_manager() const { return p_->task_manager_.get(); }
|
|
|
|
Player *Application::player() const { return p_->player_.get(); }
|
2019-11-03 19:53:08 +01:00
|
|
|
DeviceFinders *Application::device_finders() const { return p_->device_finders_.get(); }
|
2018-09-20 17:36:23 +02:00
|
|
|
#ifndef Q_OS_WIN
|
2018-10-14 00:08:33 +02:00
|
|
|
DeviceManager *Application::device_manager() const { return p_->device_manager_.get(); }
|
2018-09-20 17:36:23 +02:00
|
|
|
#endif
|
2018-07-01 22:26:46 +02:00
|
|
|
SCollection *Application::collection() const { return p_->collection_.get(); }
|
2018-10-14 00:08:33 +02:00
|
|
|
CollectionBackend *Application::collection_backend() const { return collection()->backend(); }
|
2018-02-27 18:06:05 +01:00
|
|
|
CollectionModel *Application::collection_model() const { return collection()->model(); }
|
2018-10-14 00:08:33 +02:00
|
|
|
AlbumCoverLoader *Application::album_cover_loader() const { return p_->album_cover_loader_.get(); }
|
|
|
|
CoverProviders *Application::cover_providers() const { return p_->cover_providers_.get(); }
|
2019-07-07 21:14:24 +02:00
|
|
|
CurrentAlbumCoverLoader *Application::current_albumcover_loader() const { return p_->current_albumcover_loader_.get(); }
|
2018-10-14 00:08:33 +02:00
|
|
|
LyricsProviders *Application::lyrics_providers() const { return p_->lyrics_providers_.get(); }
|
|
|
|
PlaylistBackend *Application::playlist_backend() const { return p_->playlist_backend_.get(); }
|
|
|
|
PlaylistManager *Application::playlist_manager() const { return p_->playlist_manager_.get(); }
|
2018-10-23 23:25:02 +02:00
|
|
|
InternetServices *Application::internet_services() const { return p_->internet_services_.get(); }
|
2021-07-11 01:02:53 +02:00
|
|
|
RadioServices *Application::radio_services() const { return p_->radio_services_.get(); }
|
2018-12-23 18:54:27 +01:00
|
|
|
AudioScrobbler *Application::scrobbler() const { return p_->scrobbler_.get(); }
|
2020-08-30 18:09:13 +02:00
|
|
|
LastFMImport *Application::lastfm_import() const { return p_->lastfm_import_.get(); }
|
2019-04-18 15:03:01 +02:00
|
|
|
#ifdef HAVE_MOODBAR
|
|
|
|
MoodbarController *Application::moodbar_controller() const { return p_->moodbar_controller_.get(); }
|
|
|
|
MoodbarLoader *Application::moodbar_loader() const { return p_->moodbar_loader_.get(); }
|
|
|
|
#endif
|