static bmdb_t *
bmdb_query_create(const char *query, int type, prop_t *model)
{
bmdb_t *b = calloc(1, sizeof(bmdb_t));
prop_set(model, "type", PROP_SET_STRING, "directory");
b->b_nodes = prop_create_r(model, "nodes");
b->b_metadata = prop_create_r(model, "metadata");
b->b_type = type;
b->b_query = strdup(query);
return b;
}
static JSBool
js_item_addOptAction(JSContext *cx, JSObject *obj,
uintN argc, jsval *argv, jsval *rval)
{
js_item_t *ji = JS_GetPrivate(cx, obj);
const char *title;
const char *action;
if (!JS_ConvertArguments(cx, argc, argv, "ss", &title, &action))
return JS_FALSE;
prop_t *p = prop_create_root(NULL);
prop_set_string(prop_create(p, "type"), "action");
prop_set_string(prop_create(prop_create(p, "metadata"), "title"), title);
prop_set_int(prop_create(p, "enabled"), 1);
prop_set_string(prop_create(p, "action"), action);
prop_t *opts = prop_create_r(ji->ji_root, "options");
if(prop_set_parent(p, opts))
prop_destroy(p);
prop_ref_dec(opts);
*rval = JSVAL_VOID;
return JS_TRUE;
}
static setting_t *
setting_create_leaf(prop_t *parent, prop_t *title, const char *type,
const char *valuename, int flags)
{
setting_t *s = calloc(1, sizeof(setting_t));
s->s_root = prop_ref_inc(setting_add(parent, title, type, flags));
s->s_val = prop_create_r(s->s_root, valuename);
return s;
}
static void
artist_query(bmdb_t *b, void *db)
{
sqlite3_stmt *stmt;
int rc;
int artist_id = atoi(b->b_query);
rc = db_prepare(db, &stmt,
"SELECT title "
"FROM artist "
"WHERE ds_id = 1 "
"AND id = ?1");
if(rc != SQLITE_OK)
return;
sqlite3_bind_int(stmt, 1, artist_id);
if(db_step(stmt) == SQLITE_ROW) {
rstr_t *artist = db_rstr(stmt, 0);
prop_set(b->b_metadata, "title", PROP_SET_RSTRING, artist);
prop_t *p = prop_create_r(b->b_metadata, "artist_images");
metadata_bind_artistpics(p, artist);
prop_ref_dec(p);
rstr_release(artist);
}
sqlite3_finalize(stmt);
rc = db_prepare(db, &stmt,
"SELECT id,title "
"FROM album "
"WHERE ds_id = 1 "
"AND artist_id = ?1");
if(rc != SQLITE_OK)
return;
sqlite3_bind_int(stmt, 1, artist_id);
rstr_t *ct = rstr_alloc("album");
while((rc = db_step(stmt)) == SQLITE_ROW) {
char url[PATH_MAX];
snprintf(url, sizeof(url), "library:album:%d",
sqlite3_column_int(stmt, 0));
add_item(b, url, NULL, ct,
(const char *)sqlite3_column_text(stmt, 1), 0, NULL, 0);
}
rstr_release(ct);
sqlite3_finalize(stmt);
}
static void
add_item(bmdb_t *b, const char *url, const char *parent, rstr_t *contenttype,
const char *title, int track, const char *artist, int duration)
{
prop_t *c = prop_create_r(b->b_nodes, url);
prop_unmark(c);
prop_set(c, "type", PROP_SET_RSTRING, contenttype);
prop_set(c, "url", PROP_SET_STRING, url);
prop_t *metadata = prop_create_r(c, "metadata");
if(track)
prop_set(metadata, "track", PROP_SET_INT, track);
if(artist)
prop_set(metadata, "artist", PROP_SET_STRING, artist);
if(duration > 0)
prop_set(metadata, "duration", PROP_SET_INT, duration / 1000);
if(title == NULL) {
char fname[512];
fa_url_get_last_component(fname, sizeof(fname), url);
rstr_t *ft = metadata_remove_postfix(fname);
prop_set(metadata, "title", PROP_SET_RSTRING, ft);
rstr_release(ft);
} else {
prop_set(metadata, "title", PROP_SET_STRING, title);
}
#if 0
prop_t *options = prop_create(bi->bi_prop, "options");
metadata_bind_video_info(metadata, bi->bi_url, title, NULL, 0, options,
bi->bi_prop, NULL, 0, 1);
#endif
prop_ref_dec(metadata);
prop_ref_dec(c);
}
void
playinfo_bind_url_to_prop(const char *url, prop_t *parent)
{
metadb_item_info_t mii;
mip_get(url, &mii);
metadb_item_prop_t *mip = malloc(sizeof(metadb_item_prop_t));
hts_mutex_lock(&mip_mutex);
mip->mip_refcount = 2; // One per subscription created below
mip->mip_destroy_sub =
prop_subscribe(PROP_SUB_TRACK_DESTROY,
PROP_TAG_CALLBACK, metadb_item_prop_destroyed, mip,
PROP_TAG_ROOT, parent,
PROP_TAG_MUTEX, &mip_mutex,
NULL);
assert(mip->mip_destroy_sub != NULL);
mip->mip_playcount = prop_create_r(parent, "playcount");
mip->mip_lastplayed = prop_create_r(parent, "lastplayed");
mip->mip_restartpos = prop_create_r(parent, "restartpos");
mip->mip_playcount_sub =
prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE | PROP_SUB_TRACK_DESTROY,
PROP_TAG_CALLBACK, metadb_set_playcount, mip,
PROP_TAG_ROOT, mip->mip_playcount,
PROP_TAG_MUTEX, &mip_mutex,
NULL);
assert(mip->mip_playcount_sub != NULL);
mip->mip_url = strdup(url);
unsigned int hash = mystrhash(url) % MIP_HASHWIDTH;
LIST_INSERT_HEAD(&mip_hash[hash], mip, mip_link);
mip_set(mip, &mii);
hts_mutex_unlock(&mip_mutex);
}
void
metadata_browse(void *db, const char *url, prop_t *nodes,
prop_t *model,
library_query_t type,
int (*checkstop)(void *opaque), void *opaque)
{
prop_t *status = prop_create_r(model, "status");
bmdb_t b = {0};
b.b_query = strdup(url);
b.b_type = type;
b.b_nodes = nodes;
b.b_metadata = prop_create_r(model, "metadata");
while(!checkstop(opaque)) {
int p = get_percentage(url);
if(p != 100) {
prop_set(model, "percentage", PROP_SET_INT, p);
prop_set(model, "progressmeter", PROP_SET_INT, 1);
prop_link(_p("Indexing"), status);
} else {
prop_set(model, "progressmeter", PROP_SET_INT, 0);
prop_unlink(status);
}
// int64_t ts = showtime_get_ts();
bmdb_query_exec(db, &b);
// printf("Query took %lld\n", showtime_get_ts() - ts);
prop_set(model, "loading", PROP_SET_INT, 0);
sleep(1);
}
prop_set(model, "progressmeter", PROP_SET_INT, 0);
prop_unlink(status);
free(b.b_query);
prop_ref_dec(status);
prop_ref_dec(b.b_metadata);
}
static void
album_query(bmdb_t *b, void *db)
{
sqlite3_stmt *stmt;
int rc;
int album_id = atoi(b->b_query);
rc = db_prepare(db, &stmt,
"SELECT album.title, artist.title "
"FROM album, artist "
"WHERE album.id = ?1 "
"AND artist.id = album.artist_id "
"AND album.ds_id = 1");
if(rc != SQLITE_OK)
return;
sqlite3_bind_int(stmt, 1, album_id);
if(db_step(stmt) == SQLITE_ROW) {
rstr_t *album = db_rstr(stmt, 0);
rstr_t *artist = db_rstr(stmt, 1);
prop_set(b->b_metadata, "title", PROP_SET_RSTRING, album);
prop_set(b->b_metadata, "artist_name", PROP_SET_RSTRING, artist);
prop_t *p = prop_create_r(b->b_metadata, "album_art");
metadata_bind_albumart(p, artist, album);
prop_ref_dec(p);
rstr_release(album);
rstr_release(artist);
}
sqlite3_finalize(stmt);
rc = db_prepare(db, &stmt,
"SELECT url, audioitem.title, track, duration, "
"artist.title "
"FROM audioitem,item,artist "
"WHERE audioitem.item_id = item.id "
"AND audioitem.artist_id = artist.id "
"AND album_id = ?1 "
"AND audioitem.ds_id = 1");
if(rc != SQLITE_OK)
return;
sqlite3_bind_int(stmt, 1, album_id);
rstr_t *ct = rstr_alloc("audio");
while((rc = db_step(stmt)) == SQLITE_ROW) {
add_item(b, (const char *)sqlite3_column_text(stmt, 0),
NULL, ct,
(const char *)sqlite3_column_text(stmt, 1),
sqlite3_column_int(stmt, 2),
(const char *)sqlite3_column_text(stmt, 4),
sqlite3_column_int(stmt, 3));
}
rstr_release(ct);
sqlite3_finalize(stmt);
}
int
keyring_lookup(const char *id, char **username, char **password,
char **domain, int *remember_me, const char *source,
const char *reason, int flags)
{
htsmsg_t *m;
rstr_t *r;
int remember = !!(flags & KEYRING_REMEMBER_ME_SET);
hts_mutex_lock(&keyring_mutex);
if(flags & KEYRING_QUERY_USER) {
char tmpbuf[64];
htsmsg_t *parent;
prop_t *p = prop_ref_inc(prop_create_root(NULL));
prop_set_string(prop_create(p, "type"), "auth");
prop_set_string(prop_create(p, "id"), id);
prop_set_string(prop_create(p, "source"), source);
prop_set_string(prop_create(p, "reason"), reason);
prop_set_int(prop_create(p, "disableUsername"), username == NULL);
prop_set_int(prop_create(p, "disablePassword"), password == NULL);
prop_set_int(prop_create(p, "disableDomain"), domain == NULL);
prop_set_int(prop_create(p, "canRemember"),
!!(flags & KEYRING_SHOW_REMEMBER_ME));
prop_t *rememberMe = prop_create_r(p, "rememberMe");
prop_set_int(rememberMe, remember);
prop_sub_t *remember_sub =
prop_subscribe(0,
PROP_TAG_CALLBACK_INT, set_remember, &remember,
PROP_TAG_ROOT, rememberMe,
NULL);
prop_t *user = prop_create_r(p, "username");
prop_t *pass = prop_create_r(p, "password");
prop_t *dom = prop_create_r(p, "domain");
if(domain != NULL)
prop_set_string(dom, *domain);
TRACE(TRACE_INFO, "keyring", "Requesting credentials for %s : %s : %s (%s)",
id, source, reason, hts_thread_name(tmpbuf, sizeof(tmpbuf)));
event_t *e = popup_display(p);
prop_unsubscribe(remember_sub);
if(flags & KEYRING_ONE_SHOT)
parent = NULL;
else if(remember)
parent = persistent_keyring;
else
parent = temporary_keyring;
if(parent != NULL)
htsmsg_delete_field(parent, id);
if(event_is_action(e, ACTION_OK)) {
/* OK */
m = htsmsg_create_map();
if(username != NULL) {
r = prop_get_string(user, NULL);
htsmsg_add_str(m, "username", r ? rstr_get(r) : "");
*username = strdup(r ? rstr_get(r) : "");
rstr_release(r);
}
if(domain != NULL) {
r = prop_get_string(dom, NULL);
htsmsg_add_str(m, "domain", r ? rstr_get(r) : "");
*domain = strdup(r ? rstr_get(r) : "");
rstr_release(r);
}
if(password != NULL) {
r = prop_get_string(pass, NULL);
htsmsg_add_str(m, "password", r ? rstr_get(r) : "");
*password = strdup(r ? rstr_get(r) : "");
rstr_release(r);
}
if(parent != NULL) {
htsmsg_add_msg(parent, id, m);
if(parent == persistent_keyring)
keyring_store();
}
} else {
/* CANCEL */
if(parent == persistent_keyring)
keyring_store();
}
if(remember_me != NULL)
*remember_me = remember;
prop_destroy(p);
prop_ref_dec(p);
prop_ref_dec(user);
prop_ref_dec(pass);
prop_ref_dec(dom);
prop_ref_dec(rememberMe);
if(event_is_action(e, ACTION_CANCEL)) {
/* return CANCEL to caller */
hts_mutex_unlock(&keyring_mutex);
event_release(e);
return -1;
}
event_release(e);
} else {
if((m = htsmsg_get_map(temporary_keyring, id)) == NULL &&
(m = htsmsg_get_map(persistent_keyring, id)) == NULL) {
hts_mutex_unlock(&keyring_mutex);
return 1;
}
setstr(username, m, "username");
setstr(password, m, "password");
setstr(domain, m, "domain");
}
hts_mutex_unlock(&keyring_mutex);
return 0;
}
