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)); }