static void
bookmark_add(const char *title, const char *url, const char *type)
{
bookmark_t *bm = calloc(1, sizeof(bookmark_t));
prop_t *p = prop_create_root(NULL);
prop_t *src = prop_create(p, "model");
prop_set_string(prop_create(src, "type"), "bookmark");
bm->bm_title_sub = bookmark_add_prop(src, "title", title, bm, set_title);
bm->bm_url_sub = bookmark_add_prop(src, "url", url, bm, set_url);
bm->bm_type_sub = bookmark_add_prop(src, "svctype", type, bm, set_type);
bm->bm_service = service_create(title, url, type, NULL, 1, 1);
prop_link(service_get_status_prop(bm->bm_service),
prop_create(src, "status"));
prop_link(service_get_statustxt_prop(bm->bm_service),
prop_create(src, "statustxt"));
prop_subscribe(PROP_SUB_TRACK_DESTROY | PROP_SUB_NO_INITIAL_UPDATE,
PROP_TAG_CALLBACK, bookmark_destroyed, bm,
PROP_TAG_ROOT, p,
PROP_TAG_MUTEX, &bookmark_mutex,
NULL);
if(prop_set_parent(p, prop_create(bookmarks, "nodes")))
abort();
}
void
mp_become_primary(struct media_pipe *mp)
{
mp_init_audio(mp);
if(media_primary == mp)
return;
hts_mutex_lock(&media_mutex);
assert(mp->mp_flags & MP_PRIMABLE);
if(media_primary != NULL) {
prop_set_int(media_primary->mp_prop_primary, 0);
event_t *e = event_create_action(ACTION_STOP);
mp_enqueue_event(media_primary, e);
event_release(e);
}
media_primary = mp_retain(mp);
prop_select(mp->mp_prop_root);
prop_link(mp->mp_prop_root, media_prop_current);
prop_set_int(mp->mp_prop_primary, 1);
hts_mutex_unlock(&media_mutex);
}
prop_t *
settings_create_bound_string(prop_t *parent, prop_t *title, prop_t *value)
{
prop_t *p = setting_add(parent, title, "string", 0);
prop_link(value, prop_create(p, "value"));
return p;
}
static int
be_prop_open(prop_t *page, const char *url)
{
proppage_t *pp;
openpage_t *op;
hts_mutex_lock(&pp_mutex);
LIST_FOREACH(pp, &proppages, pp_link)
if(!strcmp(rstr_get(pp->pp_url), url))
break;
if(pp == NULL) {
hts_mutex_unlock(&pp_mutex);
return 1;
}
op = calloc(1, sizeof(openpage_t));
LIST_INSERT_HEAD(&pp->pp_pages, op, op_link);
op->op_pp = pp;
op->op_root = prop_ref_inc(page);
op->op_page_sub =
prop_subscribe(PROP_SUB_TRACK_DESTROY,
PROP_TAG_CALLBACK, op_cb, op,
PROP_TAG_MUTEX, &pp_mutex,
PROP_TAG_ROOT, page,
NULL);
prop_link(pp->pp_model, prop_create(page, "model"));
hts_mutex_unlock(&pp_mutex);
return 0;
}
static void
nav_select(navigator_t *nav, nav_page_t *np, prop_t *origin)
{
prop_link(np->np_prop_root, nav->nav_prop_curpage);
prop_select_ex(np->np_prop_root, origin, NULL);
nav->nav_page_current = np;
nav_update_cango(nav);
}
prop_t *
settings_multiopt_add_opt(setting_t *s, const char *id, prop_t *title,
int selected)
{
prop_t *o = prop_create(s->s_val, id);
prop_link(title, prop_create(o, "title"));
return settings_multiopt_add(s, id, o, selected);
}
void
settings_create_info(prop_t *parent, const char *image,
prop_t *description)
{
prop_t *r = setting_add(parent, NULL, "info", 0);
prop_link(description, prop_create(r, "description"));
if(image != NULL)
prop_set_string(prop_create(r, "image"), image);
}
static void
update_service(service_instance_t *si)
{
if(si->si_service == NULL &&
si->si_setting_enabled &&
si->si_setting_title &&
si->si_setting_type) {
si->si_service = service_create(NULL, si->si_url, NULL, NULL,
si->si_probe, 0);
prop_link(settings_get_value(si->si_setting_title),
prop_create(si->si_service->s_root, "title"));
prop_link(settings_get_value(si->si_setting_type),
prop_create(si->si_service->s_root, "type"));
prop_link(settings_get_value(si->si_setting_enabled),
prop_create(si->si_service->s_root, "enabled"));
}
}
prop_t *
makesep(prop_t *title)
{
prop_t *d = prop_create_root(NULL);
prop_link(title, prop_create(prop_create(d, "metadata"), "title"));
prop_set_string(prop_create(d, "type"), "separator");
return d;
}
prop_t *
settings_add_dir(prop_t *parent, prop_t *title, const char *subtype,
const char *icon, prop_t *shortdesc,
const char *url)
{
prop_t *p = setting_add(parent, title, "settings", 0);
prop_t *metadata = prop_create(p, "metadata");
if(shortdesc != NULL)
prop_link(shortdesc, prop_create(metadata, "shortdesc"));
settings_add_dir_sup(p, url, icon, subtype);
return p;
}
void
settings_multiopt_add_opt(setting_t *s, const char *id, prop_t *title,
int selected)
{
prop_t *o = prop_create(s->s_val, id);
prop_link(title, prop_create(o, "title"));
if(selected) {
mystrset(&s->s_initial_value, id);
prop_select_ex(o, NULL, s->s_sub);
}
if(s->s_first == NULL)
s->s_first = strdup(id);
}
prop_t *
settings_add_url(prop_t *parent, prop_t *title,
const char *subtype, const char *icon,
prop_t *shortdesc, const char *url)
{
prop_t *p = setting_add(parent, title, "settings", 0);
prop_t *metadata = prop_create(p, "metadata");
if(shortdesc != NULL)
prop_link(shortdesc, prop_create(metadata, "shortdesc"));
prop_set_string(prop_create(p, "url"), url);
prop_set_string(prop_create(p, "subtype"), subtype);
if(icon != NULL)
prop_set_string(prop_create(metadata, "icon"), icon);
return p;
}
static int
be_prop_open(prop_t *page, const char *url)
{
proppage_t *pp;
hts_mutex_lock(&pp_mutex);
LIST_FOREACH(pp, &proppages, pp_link)
if(!strcmp(pp->pp_url, url))
break;
if(pp == NULL) {
hts_mutex_unlock(&pp_mutex);
return 1;
}
prop_link(pp->pp_model, prop_create(page, "model"));
hts_mutex_unlock(&pp_mutex);
return 0;
}
prop_t *
settings_add_dir(prop_t *parent, prop_t *title, const char *subtype,
const char *icon, prop_t *shortdesc)
{
char url[100];
prop_t *p = setting_add(parent ? prop_create(parent, "model") : NULL,
title, "settings");
prop_t *model = prop_create(p, "model");
prop_t *metadata = prop_create(model, "metadata");
prop_set_string(prop_create(model, "subtype"), subtype);
backend_prop_make(model, url, sizeof(url));
prop_set_string(prop_create(p, "url"), url);
if(icon != NULL)
prop_set_string(prop_create(metadata, "icon"), icon);
if(shortdesc != NULL)
prop_link(shortdesc, prop_create(metadata, "shortdesc"));
return p;
}
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 connman_service_t *
update_service(GVariant *v, const char *path, connman_service_t *after)
{
connman_service_t *cs = connman_service_find(path);
if(cs == NULL) {
GError *err = NULL;
GDBusProxy *proxy =
g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START ,
NULL,
"net.connman",
path,
"net.connman.Service",
NULL,
&err);
if(proxy == NULL) {
TRACE(TRACE_ERROR, "CONNMAN", "Unable to connect to service %s -- %s",
path, err->message);
g_error_free(err);
return NULL;
}
cs = calloc(1, sizeof(connman_service_t));
cs->cs_refcount = 1;
cs->cs_proxy = proxy;
if(after == NULL) {
TAILQ_INSERT_HEAD(&connman_services, cs, cs_link);
} else {
TAILQ_INSERT_AFTER(&connman_services, after, cs, cs_link);
}
connman_service_t *next = TAILQ_NEXT(cs, cs_link);
cs->cs_prop = prop_create_root(path);
cs->cs_path = strdup(path);
cs->cs_sub =
prop_subscribe(0,
PROP_TAG_CALLBACK_EVENT, connman_service_event, cs,
PROP_TAG_ROOT, cs->cs_prop,
PROP_TAG_COURIER, connman_courier,
NULL);
g_signal_connect(G_OBJECT(cs->cs_proxy), "g-signal",
G_CALLBACK(connman_svc_signal), cs);
// Insert at correct position
if(prop_set_parent_ex(cs->cs_prop, service_nodes,
next ? next->cs_prop : NULL, NULL))
abort();
prop_t *m = prop_create(cs->cs_prop, "metadata");
prop_link(prop_create(m, "name"), prop_create(m, "title"));
prop_set(cs->cs_prop, "type", PROP_SET_STRING, "network");
} else {
// Possibly move
TAILQ_REMOVE(&connman_services, cs, cs_link);
if(after == NULL) {
TAILQ_INSERT_HEAD(&connman_services, cs, cs_link);
} else {
TAILQ_INSERT_AFTER(&connman_services, after, cs, cs_link);
}
connman_service_t *next = TAILQ_NEXT(cs, cs_link);
prop_move(cs->cs_prop, next ? next->cs_prop : NULL);
}
// Update metadata
prop_set_from_vardict(v, prop_create(cs->cs_prop, "metadata"));
GVariant *name = g_variant_lookup_value(v, "Name", NULL);
const gchar *val = name ? g_variant_get_string(name, NULL) : NULL;
if(val)
mystrset(&cs->cs_name, val);
return cs;
}
static int
be_netconf_open(prop_t *page, const char *url0, int sync)
{
prop_link(netconf_model, prop_create(page, "model"));
return 0;
}
static void
update_events(htsp_connection_t *hc, prop_t *metadata, int id, int next)
{
int i;
htsmsg_t *m;
prop_t *events = prop_create(metadata, "list");
prop_t *current_event = prop_create(metadata, "current");
prop_t *next_event = prop_create(metadata, "next");
int linkstate = 0;
htsmsg_field_t *f;
if(id == 0) {
if(next == 0) {
// No events at all
prop_destroy_childs(events);
return;
}
id = next;
linkstate = 1;
}
m = htsmsg_create_map();
htsmsg_add_str(m, "method", "getEvents");
htsmsg_add_u32(m, "eventId", id);
htsmsg_add_u32(m, "numFollowing", EPG_TAIL);
if((m = htsp_reqreply(hc, m)) != NULL) {
htsmsg_t *events = htsmsg_get_list(m, "events");
f = events ? TAILQ_FIRST(&events->hm_fields) : NULL;
} else {
f = NULL;
}
for(i = 0; i < EPG_TAIL; i++) {
char buf[10];
uint32_t u32;
snprintf(buf, sizeof(buf), "%d", i);
if(f != NULL && f->hmf_type != HMF_MAP)
f = NULL;
if(f != NULL) {
m = htsmsg_get_map_by_field(f);
prop_t *e = prop_create(events, buf);
prop_set_string(prop_create(e, "title"), htsmsg_get_str(m, "title"));
prop_set_string(prop_create(e, "description"),
htsmsg_get_str(m, "description"));
if(!htsmsg_get_u32(m, "start", &u32))
prop_set_int(prop_create(e, "start"), u32);
if(!htsmsg_get_u32(m, "stop", &u32))
prop_set_int(prop_create(e, "stop"), u32);
switch(linkstate) {
case 0:
prop_link(e, current_event);
break;
case 1:
prop_link(e, next_event);
break;
}
linkstate++;
f = TAILQ_NEXT(f, hmf_link);
continue;
}
prop_destroy_by_name(events, buf);
switch(linkstate) {
case 0:
prop_unlink(current_event);
break;
case 1:
prop_unlink(next_event);
break;
}
linkstate++;
}
}
static int
be_settings_open(prop_t *page, const char *url0)
{
prop_link(settings_root, prop_create(page, "model"));
return 0;
}
static void
set_title2(prop_t *root, prop_t *title)
{
prop_link(title, prop_create(prop_create(root, "metadata"), "title"));
}
static void
set_title(prop_t *model, prop_t *title)
{
prop_link(title, prop_create(prop_create(model, "metadata"), "title"));
}
static void
update_events(htsp_connection_t *hc, prop_t *metadata, int id, int next)
{
int i;
htsmsg_t *m;
prop_t *events = prop_create(metadata, "list");
prop_t *current_event = prop_create(metadata, "current");
prop_t *next_event = prop_create(metadata, "next");
char buf[10];
uint32_t u32;
int linkstate = 0;
if(id == 0) {
if(next == 0) {
// No events at all
prop_destroy_childs(events);
return;
}
id = next;
linkstate = 1;
}
for(i = 0; i < EPG_TAIL; i++) {
snprintf(buf, sizeof(buf), "id%d", i);
if(id != 0) {
m = htsmsg_create_map();
htsmsg_add_str(m, "method", "getEvent");
htsmsg_add_u32(m, "eventId", id);
if((m = htsp_reqreply(hc, m)) != NULL) {
prop_t *e = prop_create(events, buf);
prop_set_string(prop_create(e, "title"), htsmsg_get_str(m, "title"));
prop_set_string(prop_create(e, "description"),
htsmsg_get_str(m, "description"));
if(!htsmsg_get_u32(m, "start", &u32))
prop_set_int(prop_create(e, "start"), u32);
if(!htsmsg_get_u32(m, "stop", &u32))
prop_set_int(prop_create(e, "stop"), u32);
switch(linkstate) {
case 0:
prop_link(e, current_event);
break;
case 1:
prop_link(e, next_event);
break;
}
linkstate++;
id = htsmsg_get_u32_or_default(m, "nextEventId", 0);
continue;
} else {
id = 0;
}
}
prop_destroy_by_name(events, buf);
switch(linkstate) {
case 0:
prop_unlink(current_event);
break;
case 1:
prop_unlink(next_event);
break;
}
linkstate++;
}
}
