mpd/src/StateFile.cxx

149 lines
3.6 KiB
C++
Raw Normal View History

/*
2016-02-26 17:54:05 +01:00
* Copyright 2003-2016 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
2013-01-02 19:52:57 +01:00
#include "StateFile.hxx"
2014-01-23 23:49:50 +01:00
#include "output/OutputState.hxx"
2014-02-27 17:12:42 +01:00
#include "queue/PlaylistState.hxx"
2014-08-07 18:35:57 +02:00
#include "fs/io/TextFile.hxx"
#include "fs/io/FileOutputStream.hxx"
#include "fs/io/BufferedOutputStream.hxx"
#include "Partition.hxx"
#include "Instance.hxx"
2014-01-24 16:25:21 +01:00
#include "mixer/Volume.hxx"
2014-02-03 22:25:54 +01:00
#include "SongLoader.hxx"
#include "util/Domain.hxx"
#include "Log.hxx"
2013-10-02 08:11:58 +02:00
#include <exception>
#include <string.h>
static constexpr Domain state_file_domain("state_file");
2008-12-29 17:29:23 +01:00
2016-12-27 23:06:34 +01:00
constexpr std::chrono::steady_clock::duration StateFile::DEFAULT_INTERVAL;
StateFile::StateFile(AllocatedPath &&_path,
std::chrono::steady_clock::duration _interval,
Partition &_partition, EventLoop &_loop)
:TimeoutMonitor(_loop),
path(std::move(_path)), path_utf8(path.ToUTF8()),
2014-08-24 12:59:45 +02:00
interval(_interval),
2016-12-27 23:13:03 +01:00
partition(_partition)
{
2013-01-14 11:00:22 +01:00
}
void
StateFile::RememberVersions()
{
prev_volume_version = sw_volume_state_get_hash();
prev_output_version = audio_output_state_get_version();
2013-10-19 18:48:38 +02:00
prev_playlist_version = playlist_state_get_hash(partition.playlist,
partition.pc);
}
bool
StateFile::IsModified() const
{
return prev_volume_version != sw_volume_state_get_hash() ||
prev_output_version != audio_output_state_get_version() ||
2013-10-19 18:48:38 +02:00
prev_playlist_version != playlist_state_get_hash(partition.playlist,
partition.pc);
}
inline void
StateFile::Write(BufferedOutputStream &os)
{
save_sw_volume_state(os);
audio_output_state_save(os, partition.outputs);
playlist_state_save(os, partition.playlist, partition.pc);
}
inline void
StateFile::Write(OutputStream &os)
{
BufferedOutputStream bos(os);
Write(bos);
bos.Flush();
}
2013-01-14 11:00:22 +01:00
void
StateFile::Write()
{
FormatDebug(state_file_domain,
"Saving state file %s", path_utf8.c_str());
try {
FileOutputStream fos(path);
Write(fos);
fos.Commit();
} catch (const std::exception &e) {
LogError(e);
}
RememberVersions();
}
2013-01-14 11:00:22 +01:00
void
StateFile::Read()
try {
bool success;
FormatDebug(state_file_domain, "Loading state file %s", path_utf8.c_str());
TextFile file(path);
#ifdef ENABLE_DATABASE
const SongLoader song_loader(partition.instance.database,
partition.instance.storage);
#else
const SongLoader song_loader(nullptr, nullptr);
#endif
2014-02-03 22:25:54 +01:00
const char *line;
2014-07-30 18:45:14 +02:00
while ((line = file.ReadLine()) != nullptr) {
success = read_sw_volume_state(line, partition.outputs) ||
audio_output_state_read(line, partition.outputs) ||
2014-02-03 22:25:54 +01:00
playlist_state_restore(line, file, song_loader,
partition.playlist,
2013-10-19 18:48:38 +02:00
partition.pc);
if (!success)
FormatError(state_file_domain,
"Unrecognized line in state file: %s",
line);
}
RememberVersions();
} catch (const std::exception &e) {
LogError(e);
}
void
StateFile::CheckModified()
{
if (!IsActive() && IsModified())
2016-12-27 23:06:34 +01:00
Schedule(interval);
}
void
StateFile::OnTimeout()
{
Write();
}