Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Database: Support for multiple search roots.

Browse source 
Support multiple roots (i.e. scan folders) using the new folder_select()
function.

Amaximum of 12 dirs can be selected, however the setting (i.e. the entire
folder list) cannot be longer than 80 chars.

The setting works similar to the autoresume dirs: Directories are seperated
by colons, e.g. "/Music:/Podcasts". Default is "/sdcard" on android, "/" on
all other targets.

Changes are made to the multiple-root logic in tagcache.c. This is to
a) provide the logic at all on native targets and b) support more than
one root before the scan even starts (until now it was used to add roots
during scan due to symlinks).

Change-Id: I64992c0678324536e8e64cd4427c8abbd8e8b39e
This commit is contained in:
Thomas Martitz 2012-07-18 23:36:57 +02:00
parent 0a645d212c
commit 63d27626e4
6 changed files with 114 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
apps/lang/english.lang
View file

@ -13100,3 +13100,17 @@
*: "Select one or more directories"
</voice>
</phrase>
<phrase>
id: LANG_SELECT_DATABASE_DIRS
desc: in settings_menu
user: core
<source>
*: "Select directories to scan"
</source>
<dest>
*: "Select directories to scan"
</dest>
<voice>
*: "Select directories to scan"
</voice>
</phrase>

21
apps/menus/settings_menu.c
View file

@ -66,6 +66,21 @@ static void tagcache_update_with_splash(void)
splash(HZ*2, ID2P(LANG_TAGCACHE_FORCE_UPDATE_SPLASH));
}
static int dirs_to_scan(void)
{
if (folder_select(global_settings.tagcache_scan_paths,
sizeof(global_settings.tagcache_scan_paths)))
{
static const char *lines[] = {ID2P(LANG_TAGCACHE_BUSY),
ID2P(LANG_TAGCACHE_FORCE_UPDATE)};
static const struct text_message message = {lines, 2};
if (gui_syncyesno_run(&message, NULL, NULL) == YESNO_YES)
tagcache_rebuild_with_splash();
}
return 0;
}
#ifdef HAVE_TC_RAMCACHE
MENUITEM_SETTING(tagcache_ram, &global_settings.tagcache_ram, NULL);
#endif
@ -83,12 +98,16 @@ MENUITEM_FUNCTION(tc_export, 0, ID2P(LANG_TAGCACHE_EXPORT),
MENUITEM_FUNCTION(tc_import, 0, ID2P(LANG_TAGCACHE_IMPORT),
(int(*)(void))tagtree_import, NULL,
NULL, Icon_NOICON);
MENUITEM_FUNCTION(tc_paths, 0, ID2P(LANG_SELECT_DATABASE_DIRS),
dirs_to_scan, NULL, NULL, Icon_NOICON);
MAKE_MENU(tagcache_menu, ID2P(LANG_TAGCACHE), 0, Icon_NOICON,
#ifdef HAVE_TC_RAMCACHE
&tagcache_ram,
#endif
&tagcache_autoupdate, &tc_init, &tc_update, &runtimedb,
&tc_export, &tc_import);
&tc_export, &tc_import, &tc_paths
);
#endif /* HAVE_TAGCACHE */
/* TAGCACHE MENU */
/***********************************/

1
apps/settings.h
View file

@ -561,6 +561,7 @@ struct user_settings
2=custom */
unsigned char autoresume_paths[MAX_PATHNAME+1]; /* colon-separated list */
bool runtimedb; /* runtime database active? */
unsigned char tagcache_scan_paths[MAX_PATHNAME+1];
#endif /* HAVE_TAGCACHE */
#if LCD_DEPTH > 1

8
apps/settings_list.c
View file

@ -316,6 +316,12 @@ static const char graphic_numeric[] = "graphic,numeric";
#endif /* HAVE_RECORDING */
#if (CONFIG_PLATFORM & PLATFORM_ANDROID)
#define DEFAULT_TAGCACHE_SCAN_PATHS "/sdcard"
#else
#define DEFAULT_TAGCACHE_SCAN_PATHS "/"
#endif
#ifdef HAVE_TOUCHSCREEN
static const char* list_pad_formatter(char *buffer, size_t buffer_size,
@ -1355,6 +1361,8 @@ const struct settings_list settings[] = {
OFFON_SETTING(0, runtimedb, LANG_RUNTIMEDB_ACTIVE, false,
"gather runtime data", NULL),
TEXT_SETTING(0, tagcache_scan_paths, "database scan paths",
DEFAULT_TAGCACHE_SCAN_PATHS, NULL, NULL),
#endif
#if CONFIG_CODEC == SWCODEC

93
apps/tagcache.c
View file

@ -4272,10 +4272,29 @@ static void __attribute__ ((noinline)) check_ignore(const char *dirname,
*unignore = file_exists(newpath);
}
/* max roots on native. on application more can be added via malloc() */
#define MAX_STATIC_ROOTS 12
static struct search_roots_ll {
const char *path;
struct search_roots_ll * next;
} roots_ll;
} roots_ll[MAX_STATIC_ROOTS];
/* check if the path is already included in the search roots, by the
* means that the path itself or one of its parents folders is in the list */
static bool search_root_exists(const char *path)
{
struct search_roots_ll *this;
for(this = &roots_ll[0]; this; this = this->next)
{
size_t root_len = strlen(this->path);
/* check if the link target is inside of an existing search root
* don't add if target is inside, we'll scan it later */
if (!strncmp(this->path, path, root_len))
return true;
}
return false;
}
#ifdef APPLICATION
/*
@ -4316,14 +4335,11 @@ static bool add_search_root(const char *name)
if (realpath(target, abs_target) == NULL)
return false;
for(this = &roots_ll; this; prev = this, this = this->next)
{
size_t root_len = strlen(this->path);
/* check if the link target is inside of an existing search root
* don't add if target is inside, we'll scan it later */
if (!strncmp(this->path, abs_target, root_len))
return false;
}
if (search_root_exists(abs_target))
return false;
/* get the end of the list */
for(this = &roots_ll[0]; this; prev = this, this = this->next);
if (prev)
{
@ -4347,14 +4363,22 @@ static bool add_search_root(const char *name)
return false;
}
static int free_search_root_single(struct search_roots_ll * start)
{
if (start < &roots_ll[0] && start >= &roots_ll[MAX_STATIC_ROOTS])
{
free(start->next);
return sizeof(struct search_roots_ll);
}
return 0;
}
static int free_search_roots(struct search_roots_ll * start)
{
int ret = 0;
if (start->next)
{
ret += free_search_roots(start->next);
ret += sizeof(struct search_roots_ll);
free(start->next);
ret += free_search_root_single(start->next);
}
return ret;
}
@ -4459,7 +4483,8 @@ void tagcache_screensync_enable(bool state)
tc_stat.syncscreen = state;
}
void tagcache_build(const char *path)
static void do_tagcache_build(const char *path[])
{
struct tagcache_header header;
bool ret;
@ -4501,17 +4526,29 @@ void tagcache_build(const char *path)
write(cachefd, &header, sizeof(struct tagcache_header));
ret = true;
roots_ll.path = path;
roots_ll.next = NULL;
roots_ll[0].path = path[0];
roots_ll[0].next = NULL;
/* i is for the path vector, j for the roots_ll array
* path can be skipped , but root_ll entries can't */
for(int i = 1, j = 1; path[i] && j < MAX_STATIC_ROOTS; i++)
{
if (search_root_exists(path[i])) /* skip this path */
continue;
roots_ll[j].path = path[i];
roots_ll[j-1].next = &roots_ll[j];
j++;
}
struct search_roots_ll * this;
/* check_dir might add new roots */
for(this = &roots_ll; this; this = this->next)
for(this = &roots_ll[0]; this; this = this->next)
{
strcpy(curpath, this->path);
ret = ret && check_dir(this->path, true);
}
if (roots_ll.next)
free_search_roots(roots_ll.next);
free_search_roots(&roots_ll[0]);
/* Write the header. */
header.magic = TAGCACHE_MAGIC;
@ -4558,6 +4595,18 @@ void tagcache_build(const char *path)
cpu_boost(false);
}
void tagcache_build(void)
{
char *vect[MAX_STATIC_ROOTS + 1]; /* +1 to ensure NULL sentinel */
char str[sizeof(global_settings.tagcache_scan_paths)];
strlcpy(str, global_settings.tagcache_scan_paths, sizeof(str));
int res = split_string(str, ':', vect, MAX_STATIC_ROOTS);
vect[res] = NULL;
do_tagcache_build((const char**)vect);
}
#ifdef HAVE_TC_RAMCACHE
static void load_ramcache(void)
{
@ -4643,11 +4692,11 @@ static void tagcache_thread(void)
case Q_REBUILD:
remove_files();
remove(TAGCACHE_FILE_TEMP);
tagcache_build("/");
tagcache_build();
break;
case Q_UPDATE:
tagcache_build("/");
tagcache_build();
#ifdef HAVE_TC_RAMCACHE
load_ramcache();
#endif
@ -4665,13 +4714,13 @@ static void tagcache_thread(void)
{
load_ramcache();
if (tc_stat.ramcache && global_settings.tagcache_autoupdate)
tagcache_build("/");
tagcache_build();
}
else
#endif
if (global_settings.tagcache_autoupdate)
{
tagcache_build("/");
tagcache_build();
/* This will be very slow unless dircache is enabled
or target is flash based, but do it anyway for

2
apps/tagcache.h
View file

@ -201,8 +201,6 @@ struct tagcache_search {
int32_t idx_id; /* Entry number in the master index. */
};
void tagcache_build(const char *path);
#ifdef __PCTOOL__
void tagcache_reverse_scan(void);
#endif