ocarina/lib/library.cpp

/*
 * Copyright 2013 (c) Anna Schumaker.
 */
#include <callback.h>
#include <filter.h>
#include <idle.h>
#include <library.h>
#include <print.h>

#include <glib.h>
#include <sstream>
#include <time.h>


/*
 * Internal library functions
 */
struct scan_info {
	Library *library;
	std :: string path;
};
static void do_scan_path(struct scan_info &);

static void read_tags(const std::string &path, Library *library)
{
	Track *track = tagdb :: add_track(path, library);
	get_callbacks()->on_library_track_add(track->id);
}

static void process_path(Library *library, const std :: string &dir,
			 const std :: string &name)
{
	struct scan_info scan;
	std :: string path = dir + "/" + name;

	if (g_file_test(path.c_str(), G_FILE_TEST_IS_DIR) == true) {
		scan.library = library;
		scan.path = path;
		idle :: schedule (do_scan_path, scan);
	} else
		read_tags(path, library);
}

static void do_scan_path(struct scan_info &scan)
{
	GDir *dir;
	const char *name;

	dir = g_dir_open(scan.path.c_str(), 0, NULL);
	if (dir == NULL)
		return;

	name = g_dir_read_name(dir);
	while (name != NULL) {
		process_path(scan.library, scan.path, name);
		name = g_dir_read_name(dir);
	}

	tagdb :: commit();
	get_callbacks()->on_library_update(scan.library->id, scan.library);
}

static void do_validate_library(unsigned int &lib_id)
{
	std :: string path;
	Database<Track> *db = &tagdb :: get_track_db();
	Database<Track>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it)) {
		Track *track = *it;
		if (track->library->id != lib_id)
			continue;

		if (g_file_test(track->path().c_str(), G_FILE_TEST_EXISTS) == false) {
			dprint("Removing file: %s\n", track->path().c_str());
			tagdb :: remove_track(track->id);
		}
	}

	get_callbacks()->on_library_update(lib_id, tagdb :: lookup_library(lib_id));
}

static void do_update_library(unsigned int lib_id)
{
	Library *library = tagdb :: lookup_library(lib_id);
	struct scan_info scan = { library, library->root_path };
	idle :: schedule(do_validate_library, lib_id);
	idle :: schedule(do_scan_path, scan);
}



/*
 * API used by the GUI begins here
 */

void library :: init()
{
	tagdb :: init();

	Database<Track> *db = &tagdb :: get_track_db();
	Database<Track>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it)) {
		if ((*it)->library->enabled)
			get_callbacks()->on_library_track_add((*it)->id);
	}

	Database<Library> *ldb = &tagdb :: get_library_db();
	Database<Library>::iterator l_it;

	for (l_it = ldb->begin(); l_it != ldb->end(); l_it = ldb->next(l_it))
		get_callbacks()->on_library_add((*l_it)->id, *l_it);
}

void library :: add_path(const std::string &dir)
{
	if (g_file_test(dir.c_str(), G_FILE_TEST_IS_DIR) == false)
		throw -E_INVAL;

	Library *library = tagdb :: add_library(dir);
	if (!library)
		return;

	get_callbacks()->on_library_add(library->id, library);
	update_path(library->id);
}

void library :: del_path(unsigned int id)
{
	Database<Track> *db = &tagdb :: get_track_db();
	Database<Track>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it)) {
		if ((*it)->library->id == id)
			get_callbacks()->on_library_track_del((*it)->id);
	}

	tagdb :: remove_library(id);
	tagdb :: commit();
}

void library :: update_path(unsigned int id)
{
	Library *library = tagdb :: lookup_library(id);
	if (library)
		do_update_library(library->id);
}

void library :: update_all()
{
	Database<Library> *db = &tagdb :: get_library_db();
	Database<Library>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it))
		update_path((*it)->id);
}

void library :: set_enabled(unsigned int id, bool enabled)
{
	Library *library = tagdb :: lookup_library(id);

	library->enabled = enabled;
	tagdb :: commit_library();

	Database<Track> *db = &(tagdb :: get_track_db());
	Database<Track>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it)) {
		if ((*it)->library->id == id) {
			if (enabled)
				get_callbacks()->on_library_track_add((*it)->id);
			else
				get_callbacks()->on_library_track_del((*it)->id);
		}
	}
}

#ifdef CONFIG_TEST
void library :: print_db(DB_Type type)
{
	switch (type) {
	case DB_ALBUM:
		break;
	case DB_ARTIST:
		break;
	case DB_GENRE:
		break;
	case DB_LIBRARY:
		break;
	case DB_TRACK:
		break;
	}
}

void library :: reset()
{
}
#endif /* CONFIG_TEST */