320 lines
8.5 KiB
C
320 lines
8.5 KiB
C
/*
|
|
* Copyright 2016 (c) Anna Schumaker.
|
|
*/
|
|
#include <core/idle.h>
|
|
#include <core/playlists/system.h>
|
|
#include <core/string.h>
|
|
|
|
static bool __sys_pl_remove(enum sys_playlist_t, struct track *);
|
|
|
|
static struct file sys_file = FILE_INIT("playlist.db", 0, 0);
|
|
static struct file sys_collection = FILE_INIT("library.q", 0, 0);
|
|
static struct playlist sys_playlists[SYS_PL_NUM_PLAYLISTS] = {
|
|
[SYS_PL_FAVORITES] = DEFINE_PLAYLIST(PL_SYSTEM, "Favorites"),
|
|
[SYS_PL_HIDDEN] = DEFINE_PLAYLIST(PL_SYSTEM, "Hidden"),
|
|
[SYS_PL_COLLECTION] = DEFINE_PLAYLIST(PL_SYSTEM, "Collection"),
|
|
[SYS_PL_HISTORY] = DEFINE_PLAYLIST(PL_SYSTEM, "History"),
|
|
[SYS_PL_UNPLAYED] = DEFINE_PLAYLIST(PL_SYSTEM, "Unplayed"),
|
|
[SYS_PL_MOST_PLAYED] = DEFINE_PLAYLIST(PL_SYSTEM, "Most Played"),
|
|
[SYS_PL_LEAST_PLAYED] = DEFINE_PLAYLIST(PL_SYSTEM, "Least Played"),
|
|
};
|
|
|
|
|
|
static enum sys_playlist_t __sys_pl_convert(const gchar *name)
|
|
{
|
|
if (string_match(name, "Favorites"))
|
|
return SYS_PL_FAVORITES;
|
|
else if (string_match(name, "Hidden") || string_match(name, "Banned"))
|
|
return SYS_PL_HIDDEN;
|
|
else if (string_match(name, "Collection"))
|
|
return SYS_PL_COLLECTION;
|
|
else if (string_match(name, "History"))
|
|
return SYS_PL_HISTORY;
|
|
else if (string_match(name, "Unplayed"))
|
|
return SYS_PL_UNPLAYED;
|
|
else if (string_match(name, "Most Played"))
|
|
return SYS_PL_MOST_PLAYED;
|
|
else if (string_match(name, "Least Played"))
|
|
return SYS_PL_LEAST_PLAYED;
|
|
return SYS_PL_NUM_PLAYLISTS;
|
|
}
|
|
|
|
static inline struct queue *__sys_pl_queue(enum sys_playlist_t plist)
|
|
{
|
|
return &sys_playlists[plist].pl_queue;
|
|
}
|
|
|
|
static void __sys_pl_save()
|
|
{
|
|
if (!file_open(&sys_file, OPEN_WRITE))
|
|
return;
|
|
|
|
file_writef(&sys_file, "%u\n 1 %s\n", 2, "Favorites");
|
|
queue_save_tracks(__sys_pl_queue(SYS_PL_FAVORITES), &sys_file);
|
|
file_writef(&sys_file, "\n1 %s\n", "Banned");
|
|
queue_save_tracks(__sys_pl_queue(SYS_PL_HIDDEN), &sys_file);
|
|
file_writef(&sys_file, "\n");
|
|
|
|
file_close(&sys_file);
|
|
}
|
|
|
|
static void __sys_pl_save_collection()
|
|
{
|
|
if (!file_open(&sys_collection, OPEN_WRITE))
|
|
return;
|
|
|
|
queue_save_flags(__sys_pl_queue(SYS_PL_COLLECTION), &sys_collection);
|
|
file_close(&sys_collection);
|
|
}
|
|
|
|
static void __sys_pl_load_playlists()
|
|
{
|
|
enum sys_playlist_t plist;
|
|
unsigned int i, n;
|
|
gchar *name;
|
|
|
|
if (!file_open(&sys_file, OPEN_READ))
|
|
return;
|
|
|
|
file_readf(&sys_file, "%u\n", &n);
|
|
for (i = 0; i < n; i++) {
|
|
file_readf(&sys_file, "%*u %m[^\n]\n", &name);
|
|
|
|
plist = __sys_pl_convert(name);
|
|
if (plist < SYS_PL_NUM_PLAYLISTS)
|
|
queue_load_tracks(__sys_pl_queue(plist), &sys_file);
|
|
g_free(name);
|
|
}
|
|
|
|
file_close(&sys_file);
|
|
return;
|
|
}
|
|
|
|
static void __sys_pl_load_collection()
|
|
{
|
|
if (!file_open(&sys_collection, OPEN_READ))
|
|
return;
|
|
|
|
queue_load_flags(__sys_pl_queue(SYS_PL_COLLECTION), &sys_collection);
|
|
queue_unset_flag(__sys_pl_queue(SYS_PL_COLLECTION), Q_SAVE_FLAGS);
|
|
queue_unset_flag(__sys_pl_queue(SYS_PL_COLLECTION), Q_SAVE_SORT);
|
|
file_close(&sys_collection);
|
|
}
|
|
|
|
static bool __sys_pl_load()
|
|
{
|
|
__sys_pl_load_playlists();
|
|
__sys_pl_load_collection();
|
|
return true;
|
|
}
|
|
|
|
static bool __sys_pl_can_add(enum sys_playlist_t plist, struct track *track,
|
|
unsigned int average)
|
|
{
|
|
if (plist == SYS_PL_COLLECTION)
|
|
return track->tr_library->li_enabled;
|
|
else if (track->tr_count == 0)
|
|
return plist == SYS_PL_UNPLAYED;
|
|
else if (track->tr_count <= average)
|
|
return plist == SYS_PL_LEAST_PLAYED;
|
|
/* track->tr_count > average */
|
|
return plist == SYS_PL_MOST_PLAYED;
|
|
}
|
|
|
|
static bool __sys_pl_add(enum sys_playlist_t plist, struct track *track,
|
|
unsigned int average)
|
|
{
|
|
if (plist != SYS_PL_FAVORITES && plist != SYS_PL_HIDDEN &&
|
|
plist != SYS_PL_HISTORY) {
|
|
if (!__sys_pl_can_add(plist, track, average))
|
|
return false;
|
|
if (queue_has(__sys_pl_queue(SYS_PL_HIDDEN), track))
|
|
return false;
|
|
}
|
|
|
|
if (plist != SYS_PL_HISTORY && queue_has(__sys_pl_queue(plist), track))
|
|
return false;
|
|
queue_add(__sys_pl_queue(plist), track);
|
|
|
|
switch (plist) {
|
|
case SYS_PL_HIDDEN:
|
|
__sys_pl_remove(SYS_PL_COLLECTION, track);
|
|
__sys_pl_remove(SYS_PL_UNPLAYED, track);
|
|
__sys_pl_remove(SYS_PL_MOST_PLAYED, track);
|
|
__sys_pl_remove(SYS_PL_LEAST_PLAYED, track);
|
|
case SYS_PL_FAVORITES:
|
|
__sys_pl_save();
|
|
break;
|
|
case SYS_PL_MOST_PLAYED:
|
|
__sys_pl_remove(SYS_PL_UNPLAYED, track);
|
|
__sys_pl_remove(SYS_PL_LEAST_PLAYED, track);
|
|
break;
|
|
case SYS_PL_LEAST_PLAYED:
|
|
__sys_pl_remove(SYS_PL_UNPLAYED, track);
|
|
__sys_pl_remove(SYS_PL_MOST_PLAYED, track);
|
|
break;
|
|
case SYS_PL_HISTORY:
|
|
queue_iter_set(__sys_pl_queue(plist),
|
|
&__sys_pl_queue(plist)->q_cur, 0);
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool __sys_pl_remove(enum sys_playlist_t plist, struct track *track)
|
|
{
|
|
if (!queue_remove_all(__sys_pl_queue(plist), track))
|
|
return false;
|
|
|
|
switch (plist) {
|
|
case SYS_PL_HIDDEN:
|
|
__sys_pl_add(SYS_PL_COLLECTION, track, track_db_average_plays());
|
|
__sys_pl_add(SYS_PL_UNPLAYED, track, track_db_average_plays());
|
|
__sys_pl_add(SYS_PL_MOST_PLAYED, track, track_db_average_plays());
|
|
__sys_pl_add(SYS_PL_LEAST_PLAYED, track, track_db_average_plays());
|
|
case SYS_PL_FAVORITES:
|
|
__sys_pl_save();
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool __sys_pl_update(enum sys_playlist_t plist)
|
|
{
|
|
unsigned int average = track_db_average_plays();
|
|
struct db_entry *dbe, *next;
|
|
|
|
db_for_each(dbe, next, track_db_get()) {
|
|
if (__sys_pl_can_add(plist, TRACK(dbe), average))
|
|
__sys_pl_add(plist, TRACK(dbe), average);
|
|
else
|
|
__sys_pl_remove(plist, TRACK(dbe));
|
|
}
|
|
|
|
queue_unset_flag(__sys_pl_queue(plist), Q_ADD_FRONT);
|
|
return true;
|
|
}
|
|
|
|
|
|
static struct queue *pl_system_get_queue(const gchar *name)
|
|
{
|
|
enum sys_playlist_t plist = __sys_pl_convert(name);
|
|
if (plist == SYS_PL_NUM_PLAYLISTS)
|
|
return NULL;
|
|
return __sys_pl_queue(plist);
|
|
}
|
|
|
|
static bool pl_system_new_delete(const gchar *name)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static bool pl_system_add_track(const gchar *name, struct track *track)
|
|
{
|
|
enum sys_playlist_t plist = __sys_pl_convert(name);
|
|
if (plist == SYS_PL_NUM_PLAYLISTS)
|
|
return false;
|
|
return __sys_pl_add(plist, track, track_db_average_plays());
|
|
}
|
|
|
|
static bool pl_system_remove_track(const gchar *name, struct track *track)
|
|
{
|
|
enum sys_playlist_t plist = __sys_pl_convert(name);
|
|
if (plist == SYS_PL_NUM_PLAYLISTS)
|
|
return false;
|
|
return __sys_pl_remove(plist, track);
|
|
}
|
|
|
|
static void pl_system_update(const gchar *name)
|
|
{
|
|
enum sys_playlist_t plist = __sys_pl_convert(name);
|
|
if (plist != SYS_PL_FAVORITES && plist != SYS_PL_HIDDEN &&
|
|
plist != SYS_PL_HISTORY)
|
|
idle_schedule(IDLE_SYNC, IDLE_FUNC(__sys_pl_update),
|
|
GUINT_TO_POINTER(plist));
|
|
}
|
|
|
|
static void pl_system_set_flag(const gchar *name, enum queue_flags flag,
|
|
bool enabled)
|
|
{
|
|
enum sys_playlist_t plist = __sys_pl_convert(name);
|
|
if (plist == SYS_PL_HISTORY || plist == SYS_PL_NUM_PLAYLISTS)
|
|
return;
|
|
if (enabled)
|
|
queue_set_flag(__sys_pl_queue(plist), flag);
|
|
else
|
|
queue_unset_flag(__sys_pl_queue(plist), flag);
|
|
|
|
if (plist == SYS_PL_COLLECTION)
|
|
__sys_pl_save_collection();
|
|
}
|
|
|
|
static void pl_system_sort(const gchar *name, enum compare_t sort, bool reset)
|
|
{
|
|
enum sys_playlist_t plist = __sys_pl_convert(name);
|
|
|
|
queue_sort(__sys_pl_queue(plist), sort, reset);
|
|
if (plist == SYS_PL_COLLECTION)
|
|
__sys_pl_save_collection();
|
|
}
|
|
|
|
|
|
struct playlist_type pl_system = {
|
|
.pl_get_queue = pl_system_get_queue,
|
|
.pl_new = pl_system_new_delete,
|
|
.pl_delete = pl_system_new_delete,
|
|
.pl_add_track = pl_system_add_track,
|
|
.pl_remove_track = pl_system_remove_track,
|
|
.pl_update = pl_system_update,
|
|
.pl_set_flag = pl_system_set_flag,
|
|
.pl_sort = pl_system_sort,
|
|
};
|
|
|
|
|
|
void pl_system_init(struct queue_ops *ops)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < SYS_PL_NUM_PLAYLISTS; i++) {
|
|
queue_init(__sys_pl_queue(i), Q_ENABLED | Q_REPEAT, ops, &sys_playlists[i]);
|
|
if (i != SYS_PL_HISTORY) {
|
|
queue_sort(__sys_pl_queue(i), COMPARE_ARTIST, true);
|
|
queue_sort(__sys_pl_queue(i), COMPARE_YEAR, false);
|
|
queue_sort(__sys_pl_queue(i), COMPARE_TRACK, false);
|
|
} else
|
|
queue_set_flag(__sys_pl_queue(i), Q_NO_SORT);
|
|
if (i >= SYS_PL_COLLECTION)
|
|
queue_set_flag(__sys_pl_queue(i), Q_ADD_FRONT);
|
|
}
|
|
|
|
idle_schedule(IDLE_SYNC, __sys_pl_load, NULL);
|
|
pl_system_update("Collection");
|
|
pl_system_update("Unplayed");
|
|
pl_system_update("Most Played");
|
|
pl_system_update("Least Played");
|
|
}
|
|
|
|
void pl_system_deinit()
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < SYS_PL_NUM_PLAYLISTS; i++)
|
|
queue_deinit(__sys_pl_queue(i));
|
|
}
|
|
|
|
void pl_system_new_track(struct track *track)
|
|
{
|
|
__sys_pl_add(SYS_PL_COLLECTION, track, 0);
|
|
__sys_pl_add(SYS_PL_UNPLAYED, track, 0);
|
|
}
|
|
|
|
void pl_system_delete_track(struct track *track)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < SYS_PL_NUM_PLAYLISTS; i++)
|
|
__sys_pl_remove(i, track);
|
|
}
|