2018-02-27 18:06:05 +01:00
|
|
|
/* This file is part of Strawberry.
|
|
|
|
Copyright 2011, David Sansome <me@davidsansome.com>
|
2024-07-01 02:06:39 +02:00
|
|
|
Copyright 2018-2024, 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-05-01 00:41:33 +02:00
|
|
|
#include "config.h"
|
|
|
|
|
2024-07-01 02:06:39 +02:00
|
|
|
#include <memory>
|
2018-05-01 00:41:33 +02:00
|
|
|
#include <string>
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
#include <QCoreApplication>
|
2018-05-01 00:41:33 +02:00
|
|
|
#include <QObject>
|
|
|
|
#include <QIODevice>
|
|
|
|
#include <QByteArray>
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
#include "tagreaderworker.h"
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2024-07-01 02:06:39 +02:00
|
|
|
#ifdef HAVE_TAGLIB
|
|
|
|
# include "tagreadertaglib.h"
|
|
|
|
# include "tagreadergme.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TAGPARSER
|
|
|
|
# include "tagreadertagparser.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
using std::make_shared;
|
|
|
|
using std::shared_ptr;
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
TagReaderWorker::TagReaderWorker(QIODevice *socket, QObject *parent)
|
2024-07-01 02:06:39 +02:00
|
|
|
: AbstractMessageHandler<spb::tagreader::Message>(socket, parent) {
|
|
|
|
|
|
|
|
#ifdef HAVE_TAGLIB
|
|
|
|
tagreaders_ << make_shared<TagReaderTagLib>();
|
|
|
|
tagreaders_ << make_shared<TagReaderGME>();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TAGPARSER
|
|
|
|
tagreaders_ << make_shared<TagReaderTagParser>();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2021-02-20 17:06:55 +01:00
|
|
|
void TagReaderWorker::MessageArrived(const spb::tagreader::Message &message) {
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2021-02-20 17:06:55 +01:00
|
|
|
spb::tagreader::Message reply;
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2024-07-01 02:06:39 +02:00
|
|
|
HandleMessage(message, reply);
|
2022-08-01 09:41:12 +02:00
|
|
|
SendReply(message, &reply);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void TagReaderWorker::DeviceClosed() {
|
|
|
|
|
|
|
|
AbstractMessageHandler<spb::tagreader::Message>::DeviceClosed();
|
|
|
|
|
|
|
|
QCoreApplication::exit();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2024-07-01 02:06:39 +02:00
|
|
|
void TagReaderWorker::HandleMessage(const spb::tagreader::Message &message, spb::tagreader::Message &reply) {
|
|
|
|
|
|
|
|
for (shared_ptr<TagReaderBase> reader : tagreaders_) {
|
|
|
|
|
|
|
|
if (message.has_is_media_file_request()) {
|
|
|
|
const QString filename = QString::fromStdString(message.is_media_file_request().filename());
|
|
|
|
const bool success = reader->IsMediaFile(filename);
|
|
|
|
reply.mutable_is_media_file_response()->set_success(success);
|
|
|
|
if (success) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (message.has_read_file_request()) {
|
|
|
|
const QString filename = QString::fromStdString(message.read_file_request().filename());
|
|
|
|
spb::tagreader::ReadFileResponse *response = reply.mutable_read_file_response();
|
|
|
|
const TagReaderBase::Result result = reader->ReadFile(filename, response->mutable_metadata());
|
|
|
|
response->set_success(result.success());
|
|
|
|
if (result.success()) {
|
|
|
|
if (response->has_error()) {
|
|
|
|
response->clear_error();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!response->has_error()) {
|
|
|
|
response->set_error(TagReaderBase::ErrorString(result).toStdString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (message.has_write_file_request()) {
|
|
|
|
const QString filename = QString::fromStdString(message.write_file_request().filename());
|
|
|
|
const TagReaderBase::Result result = reader->WriteFile(filename, message.write_file_request());
|
|
|
|
spb::tagreader::WriteFileResponse *response = reply.mutable_write_file_response();
|
|
|
|
response->set_success(result.success());
|
|
|
|
if (result.success()) {
|
|
|
|
if (response->has_error()) {
|
|
|
|
response->clear_error();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!response->has_error()) {
|
|
|
|
response->set_error(TagReaderBase::ErrorString(result).toStdString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (message.has_load_embedded_art_request()) {
|
|
|
|
const QString filename = QString::fromStdString(message.load_embedded_art_request().filename());
|
|
|
|
QByteArray data;
|
|
|
|
const TagReaderBase::Result result = reader->LoadEmbeddedArt(filename, data);
|
|
|
|
spb::tagreader::LoadEmbeddedArtResponse *response = reply.mutable_load_embedded_art_response();
|
|
|
|
response->set_success(result.success());
|
|
|
|
if (result.success()) {
|
|
|
|
response->set_data(data.toStdString());
|
|
|
|
if (response->has_error()) {
|
|
|
|
response->clear_error();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!response->has_error()) {
|
|
|
|
response->set_error(TagReaderBase::ErrorString(result).toStdString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (message.has_save_embedded_art_request()) {
|
|
|
|
const QString filename = QString::fromStdString(message.save_embedded_art_request().filename());
|
|
|
|
const TagReaderBase::Result result = reader->SaveEmbeddedArt(filename, message.save_embedded_art_request());
|
|
|
|
spb::tagreader::SaveEmbeddedArtResponse *response = reply.mutable_save_embedded_art_response();
|
|
|
|
response->set_success(result.success());
|
|
|
|
if (result.success()) {
|
|
|
|
if (response->has_error()) {
|
|
|
|
response->clear_error();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!response->has_error()) {
|
|
|
|
response->set_error(TagReaderBase::ErrorString(result).toStdString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (message.has_save_song_playcount_to_file_request()) {
|
|
|
|
const QString filename = QString::fromStdString(message.save_song_playcount_to_file_request().filename());
|
|
|
|
const TagReaderBase::Result result = reader->SaveSongPlaycountToFile(filename, message.save_song_playcount_to_file_request().playcount());
|
|
|
|
spb::tagreader::SaveSongPlaycountToFileResponse *response = reply.mutable_save_song_playcount_to_file_response();
|
|
|
|
response->set_success(result.success());
|
|
|
|
if (result.success()) {
|
|
|
|
if (response->has_error()) {
|
|
|
|
response->clear_error();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!response->has_error()) {
|
|
|
|
response->set_error(TagReaderBase::ErrorString(result).toStdString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (message.has_save_song_rating_to_file_request()) {
|
|
|
|
const QString filename = QString::fromStdString(message.save_song_rating_to_file_request().filename());
|
|
|
|
const TagReaderBase::Result result = reader->SaveSongRatingToFile(filename, message.save_song_rating_to_file_request().rating());
|
|
|
|
spb::tagreader::SaveSongRatingToFileResponse *response = reply.mutable_save_song_rating_to_file_response();
|
|
|
|
response->set_success(result.success());
|
|
|
|
if (result.success()) {
|
|
|
|
if (response->has_error()) {
|
|
|
|
response->clear_error();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!response->has_error()) {
|
|
|
|
response->set_error(TagReaderBase::ErrorString(result).toStdString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-08-01 09:41:12 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
2020-11-19 18:22:57 +01:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|