static void logger(void *data, mrp_log_level_t level, const char *file,
int line, const char *func, const char *format, va_list ap)
{
console_t *c = (console_t *)data;
va_list cp;
const char *prefix;
MRP_UNUSED(file);
MRP_UNUSED(line);
MRP_UNUSED(func);
switch (level) {
case MRP_LOG_ERROR: prefix = "[log] E: "; break;
case MRP_LOG_WARNING: prefix = "[log] W: "; break;
case MRP_LOG_INFO: prefix = "[log] I: "; break;
case MRP_LOG_DEBUG: prefix = "[log] D: "; break;
default: prefix = "[log] ?: ";
}
va_copy(cp, ap);
mrp_console_printf(c->mc, "%s", prefix);
mrp_console_vprintf(c->mc, format, cp);
mrp_console_printf(c->mc, "\n");
va_end(cp);
}
static void ignore_invalid_request(wrt_client_t *c, mrp_json_t *req, ...)
{
MRP_UNUSED(c);
MRP_UNUSED(req);
mrp_log_error("Ignoring invalid WRT resource request");
}
static void server_status_cb(mrp_dbus_t *dbus, const char *name, int up,
const char *owner, void *user_data)
{
context_t *c = (context_t *)user_data;
MRP_UNUSED(dbus);
MRP_UNUSED(name);
if (up) {
mrp_log_info("%s came up (as %s)", name, owner);
if (c->timer == NULL) {
c->timer = mrp_add_timer(c->ml, 1000, send_cb, c);
if (c->timer == NULL) {
mrp_log_error("Failed to create D-BUS sending timer.");
exit(1);
}
}
}
else {
mrp_log_info("%s went down", name);
if (c->timer != NULL) {
mrp_del_timer(c->timer);
c->timer = NULL;
}
}
}
static void render_notify(srs_t *srs, srs_voice_event_t *e, void *user_data,
void *notify_data)
{
client_t *c = (client_t *)user_data;
MRP_UNUSED(srs);
MRP_UNUSED(notify_data);
switch (e->type) {
case SRS_VOICE_EVENT_STARTED:
print(c, "Rendering of TTS #%u started...", e->id);
break;
case SRS_VOICE_EVENT_PROGRESS:
print(c, "%f %% (%u msec) of TTS #%u rendered...",
e->data.progress.pcnt, e->data.progress.msec, e->id);
break;
case SRS_VOICE_EVENT_COMPLETED:
print(c, "Rendering of TTS #%u completed.", e->id);
break;
case SRS_VOICE_EVENT_TIMEOUT:
print(c, "Rendering of TTS #%u timed out.", e->id);
break;
case SRS_VOICE_EVENT_ABORTED:
print(c, "Rendering of TTS #%u terminated abnormally.", e->id);
break;
default:
break;
}
}
static void log_target(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
const char *target;
const char *targets[32];
int i, n;
MRP_UNUSED(c);
MRP_UNUSED(user_data);
if (argc == 2) {
target = mrp_log_get_target();
n = mrp_log_get_targets(targets, MRP_ARRAY_SIZE(targets));
printf("available log targets:\n");
for (i = 0; i < n; i++)
printf(" %s%s\n", targets[i],
!strcmp(targets[i], target) ? " (active)" : "");
}
else if (argc == 3) {
target = argv[2];
if (!mrp_log_set_target(target))
printf("failed to change logging target to %s", target);
else {
printf("changed log target to %s\n", target);
mrp_log_info("changed log target to %s", target);
}
}
else {
printf("%s/%s invoked with wrong number of arguments\n",
argv[0], argv[1]);
}
}
static int notify_focus(srs_client_t *srs_client, srs_voice_focus_t focus)
{
MRP_UNUSED(srs_client);
MRP_UNUSED(focus);
return TRUE;
}
int main(int argc, char **argv)
{
mrp_mainloop_t *ml;
int mask;
mrp_io_watch_t *watch;
my_app_data app_data;
MRP_UNUSED(argc);
MRP_UNUSED(argv);
if ((ml = mrp_mainloop_create()) == NULL)
exit(1);
app_data.rs = NULL;
app_data.cx = mrp_res_create(ml, state_callback, &app_data);
mask = MRP_IO_EVENT_IN | MRP_IO_EVENT_HUP | MRP_IO_EVENT_ERR;
watch = mrp_add_io_watch(ml, fileno(stdin), (mrp_io_event_t) mask,
handle_input, &app_data);
if (!watch)
exit(1);
/* start looping */
mrp_mainloop_run(ml);
mrp_res_destroy(app_data.cx);
mrp_mainloop_destroy(ml);
app_data.cx = NULL;
app_data.rs = NULL;
return 0;
}
void event_cb(uint32_t request_id, mrp_resource_set_t *resource_set, void *user_data)
{
resource_set_lua_t *rset = (resource_set_lua_t *) user_data;
mrp_resource_mask_t grant, advice;
int top;
MRP_UNUSED(request_id);
MRP_UNUSED(resource_set);
mrp_debug("> event_cb");
top = lua_gettop(rset->L);
grant = mrp_get_resource_set_grant(rset->resource_set);
advice = mrp_get_resource_set_advice(rset->resource_set);
/* update resource set */
rset->acquired = !!grant;
rset->available = !!advice;
if (mrp_lua_object_deref_value(rset, rset->L, rset->callback, false)) {
mrp_lua_push_object(rset->L, rset);
if (lua_pcall(rset->L, 1, 0, 0) != 0)
mrp_log_error("failed to invoke Lua resource set callback: %s",
lua_tostring(rset->L, -1));
}
lua_settop(rset->L, top);
}
static int config_loader(srs_plugin_t *plugin, srs_cfg_t *settings)
{
MRP_UNUSED(plugin);
MRP_UNUSED(settings);
return TRUE;
}
static int command_notify(srs_client_t *c, int idx, int ntoken, char **tokens,
uint32_t *start, uint32_t *end, srs_audiobuf_t *audio)
{
dbusif_t *bus = (dbusif_t *)c->user_data;
const char *dest = c->id;
const char *path = SRS_CLIENT_PATH;
const char *iface = SRS_CLIENT_INTERFACE;
const char *sig = SRS_CLIENT_NOTIFY_COMMAND;
char buf[1024], *cmd, *p, *t;
int i, n, l;
MRP_UNUSED(idx);
MRP_UNUSED(start);
MRP_UNUSED(end);
MRP_UNUSED(audio);
p = cmd = buf;
l = sizeof(buf) - 1;
t = "";
for (i = 0; i < ntoken; i++) {
n = snprintf(p, l, "%s%s", t, tokens[i]);
if (n >= l)
return FALSE;
p += n;
l -= n;
t = " ";
}
return mrp_dbus_signal(bus->dbus, dest, path, iface, sig,
MRP_DBUS_TYPE_STRING, cmd, MRP_DBUS_TYPE_INVALID);
}
static void wakeup_cb(mrp_wakeup_t *w, mrp_wakeup_event_t event,
void *user_data)
{
static struct timeval prev[2] = { {0, 0}, {0, 0} };
const char *evt;
struct timeval now;
double diff;
int id;
MRP_UNUSED(w);
MRP_UNUSED(user_data);
timeval_now(&now);
switch (event) {
case MRP_WAKEUP_EVENT_TIMER: evt = "timer"; break;
case MRP_WAKEUP_EVENT_IO: evt = "I/O (or signal)"; break;
case MRP_WAKEUP_EVENT_LIMIT: evt = "limit"; break;
default: evt = "???";
}
id = user_data ? 1 : 0;
if (MRP_LIKELY(prev[id].tv_usec != 0)) {
diff = timeval_diff(&now, &prev[id]) / 1000.0;
info("woken up #%d by %s, %.2f msecs since previous", id, evt, diff);
}
prev[id] = now;
}
static void ignore_unknown_request(wrt_client_t *c, mrp_json_t *req,
const char *type)
{
MRP_UNUSED(c);
MRP_UNUSED(req);
mrp_log_error("Ignoring unknown WRT resource request '%s'", type);
}
static void resource_lua_changed(void *data, lua_State *L, int member)
{
MRP_UNUSED(data);
MRP_UNUSED(L);
MRP_UNUSED(member);
mrp_debug("> resource_changed");
}
static void attribute_lua_changed(void *data, lua_State *L, int member)
{
MRP_UNUSED(data);
MRP_UNUSED(L);
MRP_UNUSED(member);
mrp_debug("> attribute_changed");
return;
}
static const char *translate_glob(const char *pattern, char *glob, size_t size)
{
MRP_UNUSED(glob);
MRP_UNUSED(size);
/* XXX FIXME: translate pattern to glob-like */
return pattern;
}
static void debug_show(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
MRP_UNUSED(user_data);
MRP_UNUSED(argc);
MRP_UNUSED(argv);
mrp_debug_dump_config(c->stdout);
}
static void read_status(long int i, paranoia_cb_mode_t mode)
{
#if 1
MRP_UNUSED(i);
MRP_UNUSED(mode);
#else
mrp_debug("roffset: %ld, mode: 0x%x (%s)", i, mode,
paranoia_cb_mode2str[mode]);
#endif
}
static int resource_set_get_resources(void *data, lua_State *L, int member, mrp_lua_value_t *v)
{
resource_set_lua_t *rset;
void *iter = NULL;
mrp_resource_t *resource;
mrp_resource_mask_t grant, advice;
MRP_UNUSED(member);
MRP_UNUSED(v);
mrp_debug("> resource_set_get_resources");
rset = (resource_set_lua_t *) data;
if (!rset)
return luaL_error(L, "internal error");
grant = mrp_get_resource_set_grant(rset->resource_set);
advice = mrp_get_resource_set_advice(rset->resource_set);
lua_newtable(L);
/* push all resource objects to a table and return it */
while ((resource = mrp_resource_set_iterate_resources(rset->resource_set, &iter))) {
const char *name = mrp_resource_get_name(resource);
mrp_resource_mask_t mask = mrp_resource_get_mask(resource);
/* fetch and update the resource object */
resource_lua_t *res =
(resource_lua_t *) mrp_htbl_lookup(rset->resources,
(void *) name);
if (!res) {
mrp_log_error("resources out of sync: %s not found", name);
continue;
}
/* mrp_lua_object_ref_value(res, L, 0); */
res->acquired = !!(mask & grant);
res->available = !!(mask & advice);
/* TODO: update attributes */
/* push the resource to the table */
lua_pushstring(L, res->resource_name);
mrp_lua_push_object(L, res);
lua_settable(L, -3);
}
return 1;
}
void two_cb(mrp_console_t *c, void *user_data, int argc, char **argv)
{
int i;
MRP_UNUSED(c);
MRP_UNUSED(user_data);
for (i = 0; i < argc; i++) {
printf("%s(): #%d: '%s'\n", __FUNCTION__, i, argv[i]);
}
}
static void debug_set(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
int i;
MRP_UNUSED(c);
MRP_UNUSED(user_data);
for (i = 2; i < argc; i++)
mrp_debug_set_config(argv[i]);
}
static void debug_list(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
MRP_UNUSED(user_data);
MRP_UNUSED(argc);
MRP_UNUSED(argc);
MRP_UNUSED(argv);
fprintf(c->stdout, "Available debug sites:\n");
mrp_debug_dump_sites(c->stdout, 4);
}
static void debug_reset(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
MRP_UNUSED(c);
MRP_UNUSED(user_data);
MRP_UNUSED(argc);
MRP_UNUSED(argv);
mrp_debug_reset();
printf("Debugging configuration has been reset to default.");
}
static void debug_disable(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
MRP_UNUSED(c);
MRP_UNUSED(argc);
MRP_UNUSED(argv);
MRP_UNUSED(user_data);
mrp_debug_enable(FALSE);
printf("Debugging is now disabled.\n");
}
static int notify_command(srs_client_t *srs_client, int idx,
int ntoken, char **tokens,
uint32_t *start, uint32_t *end,
srs_audiobuf_t *audio)
{
context_t *ctx;
clients_t *clients;
player_t *player;
char cmd[2048];
char *e, *p, *sep;
int i;
MRP_UNUSED(idx);
MRP_UNUSED(start);
MRP_UNUSED(end);
MRP_UNUSED(audio);
if (!srs_client || !(ctx = srs_client->user_data) ||
!(clients = ctx->clients))
return FALSE;
e = (p = cmd) + (sizeof(cmd) - 1);
for (i = 0, sep = "", *p = 0; i < ntoken && p < e; i++, sep = " ")
p += snprintf(p, e-p, "%s%s", sep, tokens[i]);
if (!(player = clients->current)) {
mrp_log_info("no player to execute command '%s'", cmd);
return FALSE;
}
mrp_log_info("Mpris2 client got command '%s'\n", cmd);
if (!strcmp(cmd, "play music"))
clients_player_request_state(player, PLAY);
else if (!strcmp(cmd, "stop music"))
clients_player_request_state(player, PAUSE);
else if (!strcmp(cmd, "play next"))
clients_player_request_track(player, NEXT_TRACK);
else if (!strcmp(cmd, "play previous"))
clients_player_request_track(player, PREVIOUS_TRACK);
else if (!strcmp(cmd, "show player"))
clients_player_show(player);
else if (!strcmp(cmd, "quit player"))
clients_player_quit(player);
else if (!strcmp(cmd, "volume up"))
clients_player_adjust_volume(player, +2);
else if (!strcmp(cmd, "volume down"))
clients_player_adjust_volume(player, -2);
return TRUE;
}
static int resource_get_attributes(void *data, lua_State *L, int member, mrp_lua_value_t *v)
{
resource_lua_t *res = (resource_lua_t *) data;
MRP_UNUSED(member);
MRP_UNUSED(v);
mrp_debug("> resource_get_attributes");
mrp_lua_push_object(L, res->real_attributes);
return 1;
}
static void htbl_free_resource(void *key, void *object)
{
resource_lua_t *res = (resource_lua_t *) object;
MRP_UNUSED(key);
mrp_lua_destroy_object(res->L, NULL, 0, res);
#if 0
mrp_debug("lua-resource: htbl_free_resource %p, res: '%s'", res,
res->resource_name);
MRP_UNUSED(key);
#endif
}
static void print_owners_cb(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
char buf[2048];
MRP_UNUSED(c);
MRP_UNUSED(user_data);
MRP_UNUSED(argc);
MRP_UNUSED(argv);
mrp_resource_owner_print(buf, sizeof(buf));
printf("%s", buf);
}
static void print_sets_cb(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
char buf[8192];
MRP_UNUSED(c);
MRP_UNUSED(user_data);
MRP_UNUSED(argc);
MRP_UNUSED(argv);
mrp_application_class_print(buf, sizeof(buf), true);
printf("%s", buf);
}
static int command_cb(srs_client_t *c, int idx, int ntoken, char **tokens,
uint32_t *start, uint32_t *end, srs_audiobuf_t *audio)
{
static const char *events[] = {
[CMD_PLAY] = "play",
[CMD_STOP] = "stop",
[CMD_PAUSE] = "pause",
[CMD_NEXT] = "next",
[CMD_PREV] = "previous",
};
static int nevent = MRP_ARRAY_SIZE(events);
wrtc_t *wrtc = (wrtc_t *)c->user_data;
const char *event;
GVariantBuilder *vb;
GVariant *args;
MRP_UNUSED(start);
MRP_UNUSED(end);
MRP_UNUSED(audio);
MRP_UNUSED(tokens);
MRP_UNUSED(ntoken);
if (!wrtc->name) {
mrp_log_error("WRT media client: can't relay, got no D-Bus name.");
return TRUE;
}
if (idx < 0 || idx >= nevent) {
mrp_log_error("WRT media client: got invalid command #%d.", idx);
return TRUE;
}
else
event = events[idx];
mrp_log_info("WRT media client: relaying command %s.", event);
vb = g_variant_builder_new(G_VARIANT_TYPE("as"));
g_variant_builder_add(vb, "s", event);
args = g_variant_new("(as)", vb);
g_variant_builder_unref(vb);
g_dbus_connection_emit_signal(wrtc->gdbus, NULL,
"/srs", "org.tizen.srs", "Result",
args, NULL);
return TRUE;
}
static void handle_delayed_request(pa_mainloop_api *api,
pa_time_event *e,
const struct timeval *tv,
void *user_data)
{
player_t *player = (player_t *)user_data;
MRP_UNUSED(api);
MRP_UNUSED(e);
MRP_UNUSED(tv);
dbusif_query_playlists(player);
dbusif_set_player_state(player, player->request.state);
memset(&player->request, 0, sizeof(player->request));
}
