617 lines
No EOL
19 KiB
C++
617 lines
No EOL
19 KiB
C++
#include "dbus.hpp"
|
|
#include "log.hpp"
|
|
#include "backend.hpp"
|
|
#include <random>
|
|
#ifdef DBUS_ENABLED
|
|
MprisAPI::MprisAPI(sdbus::IConnection &connection, std::string objectPath, DBusAPI *dbus_api)
|
|
: AdaptorInterfaces(connection, std::move(objectPath))
|
|
, dbus_api(dbus_api)
|
|
, connection(connection)
|
|
{
|
|
registerAdaptor();
|
|
connection.enterEventLoopAsync();
|
|
}
|
|
void MprisAPI::Quit() {
|
|
dbus_api->Quit();
|
|
}
|
|
void MprisAPI::Pause() {
|
|
dbus_api->Paused(true);
|
|
}
|
|
void MprisAPI::PlayPause() {
|
|
dbus_api->TogglePause();
|
|
}
|
|
void MprisAPI::Stop() {
|
|
dbus_api->Stop();
|
|
}
|
|
void MprisAPI::Play() {
|
|
dbus_api->Paused(false);
|
|
}
|
|
void MprisAPI::Seek(const int64_t &offset) {
|
|
double value = offset;
|
|
value /= 1000000;
|
|
dbus_api->Position(value);
|
|
}
|
|
void MprisAPI::SetPosition(const sdbus::ObjectPath &TrackId, const int64_t &offset) {
|
|
if (TrackId == playing_track_id) {
|
|
Seek(offset);
|
|
}
|
|
}
|
|
void MprisAPI::OpenUri(const std::string &Uri) {
|
|
dbus_api->Start(Uri, true);
|
|
}
|
|
std::string MprisAPI::PlaybackStatus() {
|
|
if (dbus_api->IsStopped()) {
|
|
return "Stopped";
|
|
} else {
|
|
return dbus_api->Paused() ? "Paused" : "Playing";
|
|
}
|
|
}
|
|
double MprisAPI::Rate() {
|
|
return dbus_api->Speed() * dbus_api->Tempo();
|
|
}
|
|
void MprisAPI::Rate(const double &value) {
|
|
dbus_api->Speed(value / dbus_api->Tempo());
|
|
}
|
|
std::map<std::string, sdbus::Variant> MprisAPI::Metadata() {
|
|
std::map<std::string, sdbus::Variant> output;
|
|
if (!dbus_api->IsStopped()) {
|
|
output["mpris:length"] = (int64_t)(dbus_api->Length() * 1000000);
|
|
output["mpris:trackid"] = playing_track_id;
|
|
output["xesam:title"] = dbus_api->FileTitle();
|
|
output["xesam:url"] = dbus_api->FilePath();
|
|
} else {
|
|
output["mpris:trackid"] = empty_track_id;
|
|
}
|
|
return output;
|
|
}
|
|
double MprisAPI::Volume() {
|
|
return dbus_api->Volume();
|
|
}
|
|
void MprisAPI::Volume(const double &value) {
|
|
dbus_api->Volume(value);
|
|
}
|
|
int64_t MprisAPI::Position() {
|
|
return dbus_api->Position() * 1000000;
|
|
}
|
|
bool MprisAPI::CanPlay() {
|
|
return !dbus_api->IsStopped();
|
|
}
|
|
bool MprisAPI::CanPause() {
|
|
return !dbus_api->IsStopped();
|
|
}
|
|
bool MprisAPI::CanSeek() {
|
|
return !dbus_api->IsStopped() && dbus_api->Length() > 0;
|
|
}
|
|
|
|
std::vector<meta_t> MprisAPI::GetTracksMetadata(const std::vector<track_id_t> &TrackIds) {
|
|
std::vector<meta_t> output;
|
|
if (!dbus_api->IsStopped()) {
|
|
output.push_back(Metadata());
|
|
auto streams = dbus_api->playback->get_streams();
|
|
int i = 0;
|
|
for (auto stream : streams) {
|
|
std::map<std::string, sdbus::Variant> meta;
|
|
meta["mpris:trackid"] = std::format("{}{}", streamPrefix, i);
|
|
meta["xesam:title"] = stream.name;
|
|
i++;
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
void MprisAPI::AddTrack(const std::string &Uri, const track_id_t &AfterTrack, const bool &SetAsCurrent) {
|
|
return;
|
|
}
|
|
void MprisAPI::RemoveTrack(const track_id_t &TrackId) {
|
|
return;
|
|
}
|
|
void MprisAPI::GoTo(const track_id_t &TrackId) {
|
|
if (TrackId.starts_with(streamPrefix)) {
|
|
std::string stream = TrackId.substr(streamPrefix.length());
|
|
int streamIdx = std::stoi(stream);
|
|
dbus_api->PlayStream((uint32_t)streamIdx);
|
|
}
|
|
return;
|
|
}
|
|
std::vector<track_id_t> MprisAPI::Tracks() {
|
|
std::vector<track_id_t> output;
|
|
if (dbus_api->IsStopped()) {
|
|
return output;
|
|
}
|
|
output.push_back(playing_track_id);
|
|
auto streams = dbus_api->playback->get_streams();
|
|
int i = 0;
|
|
for (auto stream : streams) {
|
|
output.push_back(std::format("{}{}", streamPrefix, i));
|
|
i++;
|
|
}
|
|
return output;
|
|
}
|
|
bool MprisAPI::CanEditTracks() {
|
|
return false;
|
|
}
|
|
MprisAPI::~MprisAPI() {
|
|
unregisterAdaptor();
|
|
}
|
|
#endif
|
|
#ifndef DBUS_ENABLED
|
|
DBusAPI::DBusAPI(Playback *playback, bool daemon)
|
|
: playback(playback) {
|
|
|
|
}
|
|
#else
|
|
DBusAPI::DBusAPI(Playback *playback, sdbus::IConnection &connection, std::string objectPath, bool daemon)
|
|
: AdaptorInterfaces(connection, std::move(objectPath))
|
|
, daemon(daemon)
|
|
, playback(playback)
|
|
, connection(connection)
|
|
{
|
|
registerAdaptor();
|
|
playback->register_handle(this);
|
|
auto mprisConnection = sdbus::createSessionBusConnection("org.mpris.MediaPlayer2.Looper");
|
|
auto &mprisConRef = *mprisConnection.release();
|
|
mpris = new MprisAPI(mprisConRef, "/org/mpris/MediaPlayer2", this);
|
|
threadFunc = std::thread([this]() {
|
|
while (!threadExitFlag.load()) {
|
|
Update();
|
|
std::this_thread::yield();
|
|
}
|
|
});
|
|
connection.enterEventLoopAsync();
|
|
}
|
|
#endif
|
|
const char *DBusAPI::objectPath = "/com/complecwaft/Looper";
|
|
const char *DBusAPI::busName = "com.complecwaft.Looper";
|
|
DBusAPI *DBusAPI::Create(Playback *playback, bool daemon) {
|
|
#ifdef DBUS_ENABLED
|
|
auto connection = sdbus::createSessionBusConnection(busName);
|
|
auto &con_ref = *connection.release();
|
|
return new DBusAPI(playback, con_ref, objectPath, daemon);
|
|
#else
|
|
return new DBusAPI(playback, daemon);
|
|
#endif
|
|
}
|
|
#ifdef DBUS_ENABLED
|
|
double DBusAPI::Position() {
|
|
return playback->GetPosition();
|
|
}
|
|
void DBusAPI::Position(const double &value) {
|
|
playback->Seek(value);
|
|
}
|
|
double DBusAPI::Length() {
|
|
return playback->GetLength();
|
|
}
|
|
std::string DBusAPI::FilePath() {
|
|
return playback->get_current_file().value_or("");
|
|
}
|
|
std::string DBusAPI::FileTitle() {
|
|
return playback->get_current_title().value_or("");
|
|
}
|
|
void DBusAPI::Update() {
|
|
uint16_t signals = playback->handle_signals(PlaybackSignalErrorOccurred|PlaybackSignalFileChanged|PlaybackSignalPaused|PlaybackSignalPitchChanged|PlaybackSignalResumed|PlaybackSignalSeeked|PlaybackSignalSpeedChanged|PlaybackSignalStarted|PlaybackSignalStopped|PlaybackSignalTempoChanged, this);
|
|
if (signals & PlaybackSignalErrorOccurred) {
|
|
auto error = playback->GetError(this).value_or("Unknown error.");
|
|
emitErrorOccurred(error, error);
|
|
mpris->sendPropertiesChanged(mpris->playerInterface, {"PlaybackStatus", "CanSeek", "CanPlay", "CanPause", "Metadata"});
|
|
}
|
|
if (signals & PlaybackSignalFileChanged) {
|
|
emitFileChanged(playback->get_current_file().value_or(""), playback->get_current_title().value_or(""));
|
|
mpris->emitTrackMetadataChanged(mpris->playing_track_id, mpris->Metadata());
|
|
mpris->sendPropertiesChanged(mpris->playerInterface, {"Position", "Metadata"});
|
|
}
|
|
if (signals & (PlaybackSignalPaused|PlaybackSignalResumed)) {
|
|
emitPauseChanged(playback->IsPaused());
|
|
mpris->sendPropertiesChanged(mpris->playerInterface, {"PlaybackStatus"});
|
|
}
|
|
if (signals & PlaybackSignalStopped) {
|
|
emitStopped();
|
|
emitPauseChanged(playback->IsPaused());
|
|
mpris->emitTrackRemoved(mpris->playing_track_id);
|
|
mpris->sendPropertiesChanged(mpris->playerInterface, {"PlaybackStatus", "CanSeek", "CanPlay", "CanPause", "Metadata"});
|
|
}
|
|
if (signals & PlaybackSignalPitchChanged) {
|
|
emitPitchChanged(playback->GetPitch());
|
|
}
|
|
if (signals & PlaybackSignalTempoChanged) {
|
|
emitTempoChanged(playback->GetTempo());
|
|
mpris->sendPropertiesChanged(mpris->playerInterface, {"Rate"});
|
|
}
|
|
if (signals & PlaybackSignalSpeedChanged) {
|
|
emitSpeedChanged(playback->GetSpeed());
|
|
mpris->sendPropertiesChanged(mpris->playerInterface, {"Rate"});
|
|
}
|
|
if (signals & PlaybackSignalSeeked) {
|
|
emitSeeked(playback->GetPosition());
|
|
mpris->emitSeeked(playback->GetPosition() * 1000000);
|
|
mpris->sendPropertiesChanged(mpris->playerInterface, {"Position"});
|
|
}
|
|
if (signals & PlaybackSignalStarted) {
|
|
emitPlaybackEngineStarted();
|
|
mpris->emitTrackAdded(mpris->Metadata(), mpris->empty_track_id);
|
|
mpris->sendPropertiesChanged(mpris->playerInterface, {"CanSeek", "CanPlay", "CanPause", "Position", "Metadata", "PlaybackStatus"});
|
|
}
|
|
}
|
|
void DBusAPI::Activate(const std::map<std::string, sdbus::Variant> &platform_data) {
|
|
// TODO: Raise window?
|
|
}
|
|
void DBusAPI::Open(const std::vector<std::string>& uris, const std::map<std::string, sdbus::Variant> &platform_data) {
|
|
if (uris.size() > 0) {
|
|
Start(uris[0], true);
|
|
}
|
|
}
|
|
void DBusAPI::ActivateAction(const std::string &action_name, const std::vector<sdbus::Variant>& parameter, const std::map<std::string, sdbus::Variant> &platform_data) {
|
|
// Nothing yet.
|
|
}
|
|
std::string uriToPath(const std::string &uri) {
|
|
|
|
const static std::string file_prefix = "file:";
|
|
std::string tmp = uri;
|
|
if (tmp.starts_with(file_prefix)) {
|
|
tmp = tmp.substr(file_prefix.length());
|
|
return tmp;
|
|
}
|
|
return uri;
|
|
}
|
|
void DBusAPI::Start(const std::string &path, const bool &isUri) {
|
|
StartWithStreamIndex(path, isUri, 0);
|
|
}
|
|
void DBusAPI::StartWithStreamIndex(const std::string &path, const bool &isUri, const uint32_t &streamIndex) {
|
|
if (isUri) {
|
|
StartWithStreamIndex(uriToPath(path), false, streamIndex);
|
|
} else {
|
|
playback->Start(path, (int)streamIndex);
|
|
}
|
|
}
|
|
void DBusAPI::Load(const std::string &path, const bool &isUri) {
|
|
if (isUri) {
|
|
Load(uriToPath(path), false);
|
|
} else {
|
|
playback->Load(path);
|
|
}
|
|
}
|
|
void DBusAPI::Stop() {
|
|
playback->Stop();
|
|
}
|
|
void DBusAPI::TogglePause() {
|
|
playback->Pause();
|
|
}
|
|
double DBusAPI::Speed() {
|
|
return playback->GetSpeed();
|
|
}
|
|
void DBusAPI::Speed(const double &value) {
|
|
playback->SetSpeed(value);
|
|
}
|
|
double DBusAPI::Tempo() {
|
|
return playback->GetTempo();
|
|
}
|
|
void DBusAPI::Tempo(const double &value) {
|
|
playback->SetTempo(value);
|
|
}
|
|
double DBusAPI::Pitch() {
|
|
return playback->GetPitch();
|
|
}
|
|
void DBusAPI::Pitch(const double &value) {
|
|
playback->SetPitch(value);
|
|
}
|
|
double DBusAPI::Volume() {
|
|
return playback->GetVolume();
|
|
}
|
|
void DBusAPI::Volume(const double &value) {
|
|
playback->SetVolume(value);
|
|
}
|
|
bool DBusAPI::Paused() {
|
|
return playback->IsPaused();
|
|
}
|
|
void DBusAPI::Paused(const bool &value) {
|
|
if (value != playback->IsPaused()) {
|
|
playback->Pause();
|
|
}
|
|
}
|
|
bool DBusAPI::IsStopped() {
|
|
return playback->IsStopped();
|
|
}
|
|
bool DBusAPI::IsDaemon() {
|
|
return daemon;
|
|
}
|
|
std::string DBusAPI::CreateHandle() {
|
|
size_t idx = handle_idx++;
|
|
size_t hash = std::hash<size_t>()(idx);
|
|
size_t rand = (size_t)rand_engine();
|
|
size_t rand_hash = std::hash<size_t>()(rand);
|
|
std::string value = std::format("{}:{}:{}", idx, hash, rand_hash);
|
|
handles[value] = (void*)&value;
|
|
playback->register_handle(handles[value]);
|
|
return value;
|
|
}
|
|
void DBusAPI::ClearHandle(const std::string &handle) {
|
|
if (handles.contains(handle)) {
|
|
playback->unregister_handle(handles[handle]);
|
|
handles.erase(handle);
|
|
}
|
|
}
|
|
std::deque<std::string> *DBusAPI::get_errors_by_handle(const std::string &handle) {
|
|
if (handles.contains(handle)) {
|
|
auto *v_handle = handles[handle];
|
|
if (playback->errors_occurred.contains(v_handle)) {
|
|
return &playback->errors_occurred[v_handle];
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
std::string DBusAPI::PopFront(const std::string &handle) {
|
|
auto *errors_list = get_errors_by_handle(handle);
|
|
if (errors_list != nullptr) {
|
|
if (errors_list->empty()) {
|
|
return "";
|
|
}
|
|
std::string output = errors_list->front();
|
|
errors_list->pop_front();
|
|
return output;
|
|
}
|
|
return "";
|
|
}
|
|
std::string DBusAPI::PopBack(const std::string &handle) {
|
|
auto *errors_list = get_errors_by_handle(handle);
|
|
if (errors_list != nullptr) {
|
|
if (errors_list->empty()) {
|
|
return "";
|
|
}
|
|
std::string output = errors_list->back();
|
|
errors_list->pop_back();
|
|
return output;
|
|
}
|
|
return "";
|
|
}
|
|
std::string DBusAPI::PeekFront(const std::string &handle) {
|
|
auto *errors_list = get_errors_by_handle(handle);
|
|
if (errors_list != nullptr) {
|
|
if (errors_list->empty()) {
|
|
return "";
|
|
}
|
|
std::string output = errors_list->front();
|
|
return output;
|
|
}
|
|
return "";
|
|
}
|
|
void DBusAPI::Quit() {
|
|
UIBackend::running_ui_backend->QuitHandler();
|
|
}
|
|
std::string DBusAPI::PeekBack(const std::string &handle) {
|
|
auto *errors_list = get_errors_by_handle(handle);
|
|
if (errors_list != nullptr) {
|
|
if (errors_list->empty()) {
|
|
return "";
|
|
}
|
|
std::string output = errors_list->back();
|
|
return output;
|
|
}
|
|
return "";
|
|
}
|
|
uint32_t DBusAPI::GetCount(const std::string &handle) {
|
|
auto *errors_list = get_errors_by_handle(handle);
|
|
if (errors_list != nullptr) {
|
|
return errors_list->size();
|
|
}
|
|
return 0;
|
|
}
|
|
bool DBusAPI::IsEmpty(const std::string& handle) {
|
|
return GetCount(handle) == 0;
|
|
}
|
|
void DBusAPI::Clear(const std::string &handle) {
|
|
auto *errors_list = get_errors_by_handle(handle);
|
|
if (errors_list != nullptr) {
|
|
errors_list->clear();
|
|
}
|
|
}
|
|
std::vector<std::string> DBusAPI::PeekAll(const std::string &handle) {
|
|
auto *errors_list = get_errors_by_handle(handle);
|
|
if (errors_list != nullptr) {
|
|
std::vector<std::string> output;
|
|
for (auto error : (*errors_list)) {
|
|
output.push_back(error);
|
|
}
|
|
return output;
|
|
}
|
|
return std::vector<std::string>();
|
|
}
|
|
std::vector<std::string> DBusAPI::GetAllAndClear(const std::string &handle) {
|
|
auto output = PeekAll(handle);
|
|
Clear(handle);
|
|
return output;
|
|
}
|
|
uint32_t DBusAPI::StreamIdx() {
|
|
return playback->get_current_stream();
|
|
}
|
|
std::vector<sdbus::Struct<double, std::string, int32_t>> DBusAPI::GetStreams() {
|
|
std::vector<sdbus::Struct<double, std::string, int32_t>> output;
|
|
auto streams = playback->get_streams();
|
|
for (auto stream : streams) {
|
|
sdbus::Struct<double, std::string, int32_t> tmp(stream.length, stream.name, stream.id);
|
|
output.push_back(tmp);
|
|
}
|
|
return output;
|
|
}
|
|
void DBusAPI::PlayStream(const uint32_t &idx) {
|
|
playback->play_stream((int)idx);
|
|
}
|
|
#endif
|
|
DBusAPI::~DBusAPI() {
|
|
#ifdef DBUS_ENABLED
|
|
threadExitFlag.store(true);
|
|
threadFunc.join();
|
|
unregisterAdaptor();
|
|
#endif
|
|
}
|
|
bool DBusAPISender::isOnlyInstance() {
|
|
#ifdef DBUS_ENABLED
|
|
bool output;
|
|
try {
|
|
auto *tmp = Create();
|
|
output = tmp == nullptr;
|
|
delete tmp;
|
|
return output;
|
|
} catch (sdbus::Error) {
|
|
return true;
|
|
}
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
#ifdef DBUS_ENABLED
|
|
|
|
std::optional<std::string> DBusAPISender::get_current_file() {
|
|
if (IsStopped()) {
|
|
return {};
|
|
} else {
|
|
return FilePath();
|
|
}
|
|
}
|
|
std::optional<std::string> DBusAPISender::get_current_title() {
|
|
if (IsStopped()) {
|
|
return {};
|
|
} else {
|
|
return FileTitle();
|
|
}
|
|
}
|
|
void DBusAPISender::onPlaybackEngineStarted() {
|
|
set_signal(PlaybackSignalStarted);
|
|
}
|
|
void DBusAPISender::onFileChanged(const std::string &FilePath, const std::string &Title) {
|
|
set_signal(PlaybackSignalFileChanged);
|
|
}
|
|
void DBusAPISender::onSpeedChanged(const double &new_speed) {
|
|
set_signal(PlaybackSignalSpeedChanged);
|
|
}
|
|
void DBusAPISender::onTempoChanged(const double &new_tempo) {
|
|
set_signal(PlaybackSignalTempoChanged);
|
|
}
|
|
void DBusAPISender::onPitchChanged(const double &new_pitch) {
|
|
set_signal(PlaybackSignalPitchChanged);
|
|
}
|
|
void DBusAPISender::onPauseChanged(const bool &now_paused) {
|
|
set_signal(now_paused ? PlaybackSignalPaused : PlaybackSignalResumed);
|
|
}
|
|
void DBusAPISender::onStopped() {
|
|
set_signal(PlaybackSignalStopped);
|
|
}
|
|
void DBusAPISender::onErrorOccurred(const std::string &error_desc, const std::string &error_type) {
|
|
set_signal(PlaybackSignalErrorOccurred);
|
|
}
|
|
void DBusAPISender::onSeeked(const double &to_position) {
|
|
set_signal(PlaybackSignalSeeked);
|
|
}
|
|
double DBusAPISender::GetPosition() {
|
|
return ProxyInterfaces::Position();
|
|
}
|
|
double DBusAPISender::GetLength() {
|
|
return ProxyInterfaces::Length();
|
|
}
|
|
void DBusAPISender::Seek(double position) {
|
|
ProxyInterfaces::Position(position);
|
|
}
|
|
void DBusAPISender::Start(std::string filePath, int streamIdx) {
|
|
ProxyInterfaces::Start(filePath, streamIdx);
|
|
}
|
|
void DBusAPISender::Load(std::string filePath) {
|
|
ProxyInterfaces::Load(filePath, false);
|
|
}
|
|
int DBusAPISender::get_current_stream() {
|
|
return (int)ProxyInterfaces::StreamIdx();
|
|
}
|
|
std::vector<PlaybackStream> DBusAPISender::get_streams() {
|
|
std::vector<PlaybackStream> output;
|
|
auto input = ProxyInterfaces::GetStreams();
|
|
for (auto stream : input) {
|
|
PlaybackStream tmp;
|
|
tmp.length = stream.get<0>();
|
|
tmp.name = stream.get<1>();
|
|
tmp.id = stream.get<2>();
|
|
output.push_back(tmp);
|
|
}
|
|
return output;
|
|
}
|
|
bool DBusAPISender::IsPaused() {
|
|
return ProxyInterfaces::Paused();
|
|
}
|
|
void DBusAPISender::Pause() {
|
|
ProxyInterfaces::TogglePause();
|
|
}
|
|
void DBusAPISender::Stop() {
|
|
ProxyInterfaces::Stop();
|
|
}
|
|
bool DBusAPISender::IsStopped() {
|
|
return ProxyInterfaces::IsStopped();
|
|
}
|
|
void DBusAPISender::SetTempo(float tempo) {
|
|
ProxyInterfaces::Tempo(tempo);
|
|
}
|
|
void DBusAPISender::SetPitch(float pitch) {
|
|
ProxyInterfaces::Pitch(pitch);
|
|
}
|
|
void DBusAPISender::SetSpeed(float speed) {
|
|
ProxyInterfaces::Speed(speed);
|
|
}
|
|
void DBusAPISender::SetVolume(float volume) {
|
|
ProxyInterfaces::Volume(volume);
|
|
}
|
|
float DBusAPISender::GetTempo() {
|
|
return (float)ProxyInterfaces::Tempo();
|
|
}
|
|
float DBusAPISender::GetPitch() {
|
|
return (float)ProxyInterfaces::Pitch();
|
|
}
|
|
float DBusAPISender::GetSpeed() {
|
|
return (float)ProxyInterfaces::Speed();
|
|
}
|
|
float DBusAPISender::GetVolume() {
|
|
return (float)ProxyInterfaces::Volume();
|
|
}
|
|
void DBusAPISender::Update() {
|
|
|
|
}
|
|
#endif
|
|
DBusAPISender *DBusAPISender::Create() {
|
|
#ifdef DBUS_ENABLED
|
|
try {
|
|
auto connection = sdbus::createSessionBusConnection();
|
|
auto &con_ref = *connection.release();
|
|
auto *output = new DBusAPISender(con_ref, DBusAPI::busName, DBusAPI::objectPath);
|
|
return output;
|
|
} catch (sdbus::Error error) {
|
|
DEBUG.writefln("sdbus::Error: %s: %s", error.getName().c_str(), error.getMessage().c_str());
|
|
return nullptr;
|
|
}
|
|
#else
|
|
return nullptr;
|
|
#endif
|
|
}
|
|
#ifdef DBUS_ENABLED
|
|
DBusAPISender::DBusAPISender(sdbus::IConnection &connection, std::string busName, std::string objectPath)
|
|
: ProxyInterfaces(connection, std::move(busName), std::move(objectPath)) {
|
|
registerProxy();
|
|
DEBUG.writeln("Pinging DBus API to check for its existance.");
|
|
Ping();
|
|
DEBUG.writeln("Requesting handle...");
|
|
handle = CreateHandle();
|
|
DEBUG.writeln("Preparing updates for UI frontend...");
|
|
if (IsStopped()) {
|
|
set_signal(PlaybackSignalStopped);
|
|
} else {
|
|
filePath = ProxyInterfaces::FilePath();
|
|
title = ProxyInterfaces::FileTitle();
|
|
length = ProxyInterfaces::Length();
|
|
set_signal(PlaybackSignalStarted|PlaybackSignalSeeked|PlaybackSignalFileChanged);
|
|
}
|
|
if (IsPaused()) {
|
|
set_signal(PlaybackSignalPaused);
|
|
} else {
|
|
set_signal(PlaybackSignalResumed);
|
|
}
|
|
set_signal(PlaybackSignalSpeedChanged|PlaybackSignalPitchChanged|PlaybackSignalTempoChanged);
|
|
connection.enterEventLoopAsync();
|
|
}
|
|
DBusAPISender::~DBusAPISender() {
|
|
DEBUG.writeln("Requesting handle deletion...");
|
|
ClearHandle(handle);
|
|
unregisterProxy();
|
|
}
|
|
#endif |