#define ADMIN_NAME_OWNER_CHANGED "NameOwnerChanged"
-#define POLICY_DBUS_INTERFACE "com.nokia.policy"
-#define POLICY_DBUS_MYPATH "/com/nokia/policy/enforce/pulseaudio"
-#define POLICY_DBUS_MYNAME "com.nokia.policy.pulseaudio"
-#define POLICY_DBUS_PDPATH "/com/nokia/policy"
-#define POLICY_DBUS_PDNAME "org.freedesktop.ohm"
+#define POLICY_DBUS_INTERFACE "org.tizen.policy"
+#define POLICY_DBUS_MRPPATH "/org/tizen/policy"
+#define POLICY_DBUS_MRPNAME "org.tizen.murphy"
+
+#define AUDIOMGR_DBUS_INTERFACE "org.genivi.audiomanager"
+#define AUDIOMGR_DBUS_PATH "/org/genivi/audiomanager"
+#define AUDIOMGR_DBUS_ROUTE_NAME "RoutingInterface"
+#define AUDIOMGR_DBUS_ROUTE_PATH "RoutingInterface"
+
+#define AUDIOMGR_REGISTER_DOMAIN "registerDomain"
+#define AUDIOMGR_REGISTER_SOURCE "registerSource"
+#define AUDIOMGR_REGISTER_SINK "registerSink"
+#define AUDIOMGR_REGISTER_GATEWAY "registerGateway"
+
+#define AUDIOMGR_CONNECT_ACK "ackConnect"
+#define AUDIOMGR_DISCONNECT_ACK "ackDisconnect"
+#define AUDIOMGR_SETSINKVOL_ACK "ackSetSinkVolume"
+#define AUDIOMGR_SETSRCVOL_ACK "ackSetSourceVolume"
+#define AUDIOMGR_SINKVOLTICK_ACK "ackSinkVolumeTick"
+#define AUDIOMGR_SRCVOLTICK_ACK "ackSourceVolumeTick"
+#define AUDIOMGR_SETSINKPROP_ACK "ackSetSinkSoundProperty"
#define POLICY_DECISION "decision"
#define POLICY_STREAM_INFO "stream_info"
#define PROP_ROUTE_SOURCE_MODE "policy.source_route.mode"
#define PROP_ROUTE_SOURCE_HWID "policy.source_route.hwid"
+#define AUDIOMGR_DOMAIN "PULSE"
+#define AUDIOMGR_NODE "pulsePlugin"
#define STRUCT_OFFSET(s,m) ((char *)&(((s *)0)->m) - (char *)0)
struct pa_policy_dbusif {
pa_dbus_connection *conn;
- char *ifnam; /* signal interface */
- char *mypath; /* my signal path */
- char *pdpath; /* policy daemon's signal path */
- char *pdnam; /* policy daemon's D-Bus name */
- char *admrule; /* match rule to catch name changes */
- char *actrule; /* match rule to catch action signals */
- char *strrule; /* match rule to catch stream info signals */
- int regist; /* wheter or not registered to policy daemon*/
+ char *ifnam; /* signal interface */
+ char *mrppath; /* murphy signal path */
+ char *mrpnam; /* murphy D-Bus name */
+ char *ampath; /* audio manager path */
+ char *amnam; /* audio manager name */
+ char *amrpath; /* audio manager routing path */
+ char *amrnam; /* audio manager routing name */
+ char *admmrule; /* match rule to catch murphy name changes */
+ char *admarule; /* match rule to catch audiomgr name change*/
+ char *actrule; /* match rule to catch action signals */
+ char *strrule; /* match rule to catch stream info signals */
+ int mregist; /* are we registered to murphy */
+ int amisup; /* is the audio manager up */
};
struct actdsc { /* action descriptor */
char *value;
};
-static int action_parser(DBusMessageIter *, struct argdsc *, void *, int);
-static int audio_route_parser(struct userdata *, DBusMessageIter *);
-static int volume_limit_parser(struct userdata *, DBusMessageIter *);
-static int audio_cork_parser(struct userdata *, DBusMessageIter *);
-static int audio_mute_parser(struct userdata *, DBusMessageIter *);
-static int context_parser(struct userdata *, DBusMessageIter *);
+static void pa_policy_free_dbusif(struct pa_policy_dbusif *,struct userdata *);
static DBusHandlerResult filter(DBusConnection *, DBusMessage *, void *);
+
static void handle_admin_message(struct userdata *, DBusMessage *);
static void handle_info_message(struct userdata *, DBusMessage *);
static void handle_action_message(struct userdata *, DBusMessage *);
-static void registration_cb(DBusPendingCall *, void *);
-static int register_to_pdp(struct pa_policy_dbusif *, struct userdata *);
+static void murphy_registration_cb(DBusPendingCall *, void *);
+static int register_to_murphy(struct pa_policy_dbusif *, struct userdata *);
static int signal_status(struct userdata *, uint32_t, uint32_t);
-static void pa_policy_free_dbusif(struct pa_policy_dbusif *,struct userdata *);
+
+static void audiomgr_registration_cb(DBusPendingCall *, void *);
+static int register_to_audiomgr(struct pa_policy_dbusif *, struct userdata *);
struct pa_policy_dbusif *pa_policy_dbusif_init(struct userdata *u,
const char *ifnam,
- const char *mypath,
- const char *pdpath,
- const char *pdnam)
+ const char *mrppath,
+ const char *mrpnam,
+ const char *ampath,
+ const char *amnam)
{
pa_module *m = u->module;
struct pa_policy_dbusif *dbusif = NULL;
DBusConnection *dbusconn;
DBusError error;
+ char nambuf[128];
+ char pathbuf[128];
+ char *amrnam;
+ char *amrpath;
char actrule[512];
char strrule[512];
- char admrule[512];
+ char admmrule[512];
+ char admarule[512];
dbusif = pa_xnew0(struct pa_policy_dbusif, 1);
dbus_error_init(&error);
- dbusif->conn = pa_dbus_bus_get(m->core, DBUS_BUS_SYSTEM, &error);
+ dbusif->conn = pa_dbus_bus_get(m->core, DBUS_BUS_SESSION, &error);
if (dbusif->conn == NULL || dbus_error_is_set(&error)) {
- pa_log("%s: failed to get SYSTEM Bus: %s: %s",
+ pa_log("%s: failed to get SESSION Bus: %s: %s",
__FILE__, error.name, error.message);
goto fail;
}
dbusconn = pa_dbus_connection_get(dbusif->conn);
-#if 0
- flags = DBUS_NAME_FLAG_REPLACE_EXISTING | DBUS_NAME_FLAG_DO_NOT_QUEUE;
- result = dbus_bus_request_name(dbusconn, POLICY_DBUS_MYNAME, flags,&error);
-
- if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER &&
- result != DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER ) {
- pa_log("%s: D-Bus name request failed: %s: %s",
- __FILE__, error.name, error.message);
- goto fail;
- }
-#endif
if (!dbus_connection_add_filter(dbusconn, filter,u, NULL)) {
pa_log("%s: failed to add filter function", __FILE__);
if (!ifnam)
ifnam = POLICY_DBUS_INTERFACE;
- if (!mypath)
- mypath = POLICY_DBUS_MYPATH;
+ if (!mrppath)
+ mrppath = POLICY_DBUS_MRPPATH;
+
+ if (!mrpnam)
+ mrpnam = POLICY_DBUS_MRPNAME;
+
+ if (ampath && *ampath) {
+ char *slash = ampath[strlen(ampath)-1] == '/' ? "" : "/";
+ snprintf(pathbuf, sizeof(pathbuf), "%s%s" AUDIOMGR_DBUS_ROUTE_PATH,
+ ampath, slash);
+ amrpath = pathbuf;
+ }
+ else {
+ ampath = AUDIOMGR_DBUS_PATH;
+ amrpath = AUDIOMGR_DBUS_PATH "/" AUDIOMGR_DBUS_ROUTE_PATH;
+ }
+
+ if (amnam && *amnam){
+ char *dot = amnam[strlen(amnam)-1] == '.' ? "" : ".";
+ snprintf(nambuf, sizeof(nambuf), "%s%s" AUDIOMGR_DBUS_ROUTE_NAME,
+ amnam, dot);
+ amrnam = nambuf;
+ }
+ {
+ amnam = AUDIOMGR_DBUS_INTERFACE;
+ amrnam = AUDIOMGR_DBUS_INTERFACE "." AUDIOMGR_DBUS_ROUTE_NAME;
+ }
+
- if (!pdpath)
- pdpath = POLICY_DBUS_PDPATH;
- if (!pdnam)
- pdnam = POLICY_DBUS_PDNAME;
+ snprintf(admmrule, sizeof(admmrule), "type='signal',sender='%s',path='%s',"
+ "interface='%s',member='%s',arg0='%s'", ADMIN_DBUS_MANAGER,
+ ADMIN_DBUS_PATH, ADMIN_DBUS_INTERFACE, ADMIN_NAME_OWNER_CHANGED,
+ mrpnam);
+ dbus_bus_add_match(dbusconn, admmrule, &error);
- snprintf(admrule, sizeof(admrule), "type='signal',sender='%s',path='%s',"
+ snprintf(admarule, sizeof(admarule), "type='signal',sender='%s',path='%s',"
"interface='%s',member='%s',arg0='%s'", ADMIN_DBUS_MANAGER,
ADMIN_DBUS_PATH, ADMIN_DBUS_INTERFACE, ADMIN_NAME_OWNER_CHANGED,
- pdnam);
- dbus_bus_add_match(dbusconn, admrule, &error);
+ amnam);
+ dbus_bus_add_match(dbusconn, admarule, &error);
if (dbus_error_is_set(&error)) {
pa_log("%s: unable to subscribe name change signals on %s: %s: %s",
snprintf(actrule, sizeof(actrule), "type='signal',interface='%s',"
"member='%s',path='%s/%s'", ifnam, POLICY_ACTIONS,
- pdpath, POLICY_DECISION);
+ mrppath, POLICY_DECISION);
dbus_bus_add_match(dbusconn, actrule, &error);
if (dbus_error_is_set(&error)) {
snprintf(strrule, sizeof(strrule), "type='signal',interface='%s',"
"member='%s',path='%s/%s'", ifnam, POLICY_STREAM_INFO,
- pdpath, POLICY_DECISION);
+ mrppath, POLICY_DECISION);
dbus_bus_add_match(dbusconn, strrule, &error);
if (dbus_error_is_set(&error)) {
pa_log_info("%s: subscribed policy signals on %s", __FILE__, ifnam);
- dbusif->ifnam = pa_xstrdup(ifnam);
- dbusif->mypath = pa_xstrdup(mypath);
- dbusif->pdpath = pa_xstrdup(pdpath);
- dbusif->pdnam = pa_xstrdup(pdnam);
- dbusif->admrule = pa_xstrdup(admrule);
- dbusif->actrule = pa_xstrdup(actrule);
- dbusif->strrule = pa_xstrdup(strrule);
-
- register_to_pdp(dbusif, u);
+ dbusif->ifnam = pa_xstrdup(ifnam);
+ dbusif->mrppath = pa_xstrdup(mrppath);
+ dbusif->mrpnam = pa_xstrdup(mrpnam);
+ dbusif->ampath = pa_xstrdup(ampath);
+ dbusif->amnam = pa_xstrdup(amnam);
+ dbusif->amrpath = pa_xstrdup(amrpath);
+ dbusif->amrnam = pa_xstrdup(amrnam);
+ dbusif->admmrule = pa_xstrdup(admmrule);
+ dbusif->admarule = pa_xstrdup(admarule);
+ dbusif->actrule = pa_xstrdup(actrule);
+ dbusif->strrule = pa_xstrdup(strrule);
+
+ register_to_murphy(dbusif, u);
+ //register_to_audiomgr(dbusif, u);
return dbusif;
dbus_connection_remove_filter(dbusconn, filter,u);
}
- dbus_bus_remove_match(dbusconn, dbusif->admrule, NULL);
+ dbus_bus_remove_match(dbusconn, dbusif->admmrule, NULL);
+ dbus_bus_remove_match(dbusconn, dbusif->admarule, NULL);
dbus_bus_remove_match(dbusconn, dbusif->actrule, NULL);
dbus_bus_remove_match(dbusconn, dbusif->strrule, NULL);
}
pa_xfree(dbusif->ifnam);
- pa_xfree(dbusif->mypath);
- pa_xfree(dbusif->pdpath);
- pa_xfree(dbusif->pdnam);
- pa_xfree(dbusif->admrule);
+ pa_xfree(dbusif->mrppath);
+ pa_xfree(dbusif->mrpnam);
+ pa_xfree(dbusif->ampath);
+ pa_xfree(dbusif->amnam);
+ pa_xfree(dbusif->amrpath);
+ pa_xfree(dbusif->amrnam);
+ pa_xfree(dbusif->admmrule);
+ pa_xfree(dbusif->admarule);
pa_xfree(dbusif->actrule);
pa_xfree(dbusif->strrule);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
+/**************************************************************************
+ *
+ * Murphy interfaces
+ *
+ */
static void handle_admin_message(struct userdata *u, DBusMessage *msg)
{
struct pa_policy_dbusif *dbusif;
return;
}
- if (strcmp(name, dbusif->pdnam)) {
- return;
- }
-
- if (after && strcmp(after, "")) {
- pa_log_debug("policy decision point is up");
+ if (!strcmp(name, dbusif->mrpnam)) {
+ if (after && strcmp(after, "")) {
+ pa_log_debug("murphy is up");
- if (!dbusif->regist) {
- register_to_pdp(dbusif, u);
+ if (!dbusif->mregist) {
+ register_to_murphy(dbusif, u);
+ }
}
- }
+ if (name && before && (!after || !strcmp(after, ""))) {
+ pa_log_info("murphy is gone");
+ dbusif->mregist = 0;
+ }
+ } else
+
+ if (!strcmp(name, dbusif->amnam)) {
+ if (after && strcmp(after, "")) {
+ pa_log_debug("audio manager is up");
- if (name && before && (!after || !strcmp(after, ""))) {
- pa_log_info("policy decision point is gone");
- dbusif->regist = 0;
- }
+ if (!dbusif->amisup) {
+ register_to_audiomgr(dbusif, u);
+ }
+ }
+
+ if (name && before && (!after || !strcmp(after, ""))) {
+ pa_log_info("audio manager is gone");
+ dbusif->amisup = 0;
+ }
+ }
}
static void handle_info_message(struct userdata *u, DBusMessage *msg)
static void handle_action_message(struct userdata *u, DBusMessage *msg)
{
static struct actdsc actions[] = {
+/*
{ "com.nokia.policy.audio_route" , audio_route_parser },
{ "com.nokia.policy.volume_limit", volume_limit_parser },
{ "com.nokia.policy.audio_cork" , audio_cork_parser },
{ "com.nokia.policy.audio_mute" , audio_mute_parser },
{ "com.nokia.policy.context" , context_parser },
+*/
{ NULL , NULL }
};
signal_status(u, txid, success);
}
-static int action_parser(DBusMessageIter *actit, struct argdsc *descs,
- void *args, int len)
-{
- DBusMessageIter cmdit;
- DBusMessageIter argit;
- DBusMessageIter valit;
- struct argdsc *desc;
- char *argname;
- void *argval;
-
- dbus_message_iter_recurse(actit, &cmdit);
-
- memset(args, 0, len);
-
- do {
- if (dbus_message_iter_get_arg_type(&cmdit) != DBUS_TYPE_STRUCT)
- return FALSE;
-
- dbus_message_iter_recurse(&cmdit, &argit);
-
- if (dbus_message_iter_get_arg_type(&argit) != DBUS_TYPE_STRING)
- return FALSE;
-
- dbus_message_iter_get_basic(&argit, (void *)&argname);
-
- if (!dbus_message_iter_next(&argit))
- return FALSE;
-
- if (dbus_message_iter_get_arg_type(&argit) != DBUS_TYPE_VARIANT)
- return FALSE;
-
- dbus_message_iter_recurse(&argit, &valit);
-
- for (desc = descs; desc->name != NULL; desc++) {
- if (!strcmp(argname, desc->name)) {
- if (desc->offs + (int)sizeof(char *) > len) {
- pa_log("%s: %s() desc offset %d is out of range %d",
- __FILE__, __FUNCTION__, desc->offs, len);
- return FALSE;
- }
- else {
- if (dbus_message_iter_get_arg_type(&valit) != desc->type)
- return FALSE;
-
- argval = (char *)args + desc->offs;
-
- dbus_message_iter_get_basic(&valit, argval);
- }
- break;
- }
- }
-
- } while (dbus_message_iter_next(&cmdit));
-
- return TRUE;
-}
-
-static int audio_route_parser(struct userdata *u, DBusMessageIter *actit)
-{
- static struct argdsc descs[] = {
- {"type" , STRUCT_OFFSET(struct argrt, type) , DBUS_TYPE_STRING },
- {"device", STRUCT_OFFSET(struct argrt, device), DBUS_TYPE_STRING },
- {"mode" , STRUCT_OFFSET(struct argrt, mode), DBUS_TYPE_STRING },
- {"hwid" , STRUCT_OFFSET(struct argrt, hwid), DBUS_TYPE_STRING },
- { NULL , 0 , DBUS_TYPE_INVALID}
- };
-
- struct argrt args;
- enum pa_policy_route_class class;
- char *target;
- char *mode;
- char *hwid;
- pa_proplist *p = NULL;
-
- do {
- if (!action_parser(actit, descs, &args, sizeof(args)))
- return FALSE;
-
- if (args.type == NULL || args.device == NULL)
- return FALSE;
-
- if (!strcmp(args.type, "sink"))
- class = pa_policy_route_to_sink;
- else if (!strcmp(args.type, "source"))
- class = pa_policy_route_to_source;
- else
- return FALSE;
-
- target = args.device;
- mode = (args.mode && strcmp(args.mode, "na")) ? args.mode : "";
- hwid = (args.hwid && strcmp(args.hwid, "na")) ? args.hwid : "";
-
- pa_log_debug("route %s to %s (%s|%s)", args.type, target, mode, hwid);
-
- p = pa_proplist_new();
-
- if (class == pa_policy_route_to_sink) {
- pa_proplist_sets(p, PROP_ROUTE_SINK_TARGET, target);
- pa_proplist_sets(p, PROP_ROUTE_SINK_MODE, mode);
- pa_proplist_sets(p, PROP_ROUTE_SINK_HWID, hwid);
- } else {
- pa_proplist_sets(p, PROP_ROUTE_SOURCE_TARGET, target);
- pa_proplist_sets(p, PROP_ROUTE_SOURCE_MODE, mode);
- pa_proplist_sets(p, PROP_ROUTE_SOURCE_HWID, hwid);
- }
-
- pa_module_update_proplist(u->module, PA_UPDATE_REPLACE, p);
- pa_proplist_free(p);
-
- if (pa_card_ext_set_profile(u, target) < 0 ||
- (class == pa_policy_route_to_sink &&
- pa_sink_ext_set_ports(u, target) < 0) ||
- (class == pa_policy_route_to_source &&
- pa_source_ext_set_ports(u, target) < 0) ||
- pa_policy_group_move_to(u, NULL, class, target, mode, hwid) < 0)
- {
- pa_log("%s: can't route to %s %s", __FILE__, args.type, target);
- return FALSE;
- }
-
- } while (dbus_message_iter_next(actit));
-
- return TRUE;
-}
-
-static int volume_limit_parser(struct userdata *u, DBusMessageIter *actit)
-{
- static struct argdsc descs[] = {
- {"group", STRUCT_OFFSET(struct argvol, group), DBUS_TYPE_STRING },
- {"limit", STRUCT_OFFSET(struct argvol, limit), DBUS_TYPE_INT32 },
- { NULL , 0 , DBUS_TYPE_INVALID}
- };
-
- struct argvol args;
- int success = TRUE;
-
- do {
- if (!action_parser(actit, descs, &args, sizeof(args))) {
- success = FALSE;
- break;
- }
-
- if (args.group == NULL || args.limit < 0 || args.limit > 100) {
- success = FALSE;
- break;
- }
-
- pa_log_debug("volume limit (%s|%d)", args.group, args.limit);
-
- pa_policy_group_volume_limit(u, args.group, (uint32_t)args.limit);
-
- } while (dbus_message_iter_next(actit));
-
- pa_sink_ext_set_volumes(u);
-
- return success;
-}
-
-static int audio_cork_parser(struct userdata *u, DBusMessageIter *actit)
-{
- static struct argdsc descs[] = {
- {"group", STRUCT_OFFSET(struct argcork, group), DBUS_TYPE_STRING },
- {"cork" , STRUCT_OFFSET(struct argcork, cork) , DBUS_TYPE_STRING },
- { NULL , 0 , DBUS_TYPE_INVALID}
- };
-
- struct argcork args;
- char *grp;
- int val;
-
- do {
- if (!action_parser(actit, descs, &args, sizeof(args)))
- return FALSE;
-
- if (args.group == NULL || args.cork == NULL)
- return FALSE;
-
- grp = args.group;
-
- if (!strcmp(args.cork, "corked"))
- val = 1;
- else if (!strcmp(args.cork, "uncorked"))
- val = 0;
- else
- return FALSE;
-
- pa_log_debug("cork stream (%s|%d)", grp, val);
- pa_policy_group_cork(u, grp, val);
-
- } while (dbus_message_iter_next(actit));
-
- return TRUE;
-}
-
-static int audio_mute_parser(struct userdata *u, DBusMessageIter *actit)
-{
- static struct argdsc descs[] = {
- {"device", STRUCT_OFFSET(struct argmute, device), DBUS_TYPE_STRING },
- {"mute" , STRUCT_OFFSET(struct argmute, mute) , DBUS_TYPE_STRING },
- { NULL , 0 , DBUS_TYPE_INVALID}
- };
-
- struct argmute args;
- char *device;
- int val;
-
- do {
- if (!action_parser(actit, descs, &args, sizeof(args)))
- return FALSE;
-
- if (args.device == NULL || args.mute == NULL)
- return FALSE;
-
- device = args.device;
-
- if (!strcmp(args.mute, "muted"))
- val = 1;
- else if (!strcmp(args.mute, "unmuted"))
- val = 0;
- else
- return FALSE;
-
- pa_log_debug("mute device (%s|%d)", device, val);
- pa_source_ext_set_mute(u, device, val);
-
- } while (dbus_message_iter_next(actit));
-
- return TRUE;
-}
-
-static int context_parser(struct userdata *u, DBusMessageIter *actit)
-{
- static struct argdsc descs[] = {
- {"variable", STRUCT_OFFSET(struct argctx,variable), DBUS_TYPE_STRING },
- {"value" , STRUCT_OFFSET(struct argctx,value) , DBUS_TYPE_STRING },
- { NULL , 0 , DBUS_TYPE_INVALID}
- };
-
- struct argctx args;
-
- do {
- if (!action_parser(actit, descs, &args, sizeof(args)))
- return FALSE;
-
- if (args.variable == NULL || args.value == NULL)
- return FALSE;
-
- pa_log_debug("context (%s|%s)", args.variable, args.value);
-
- pa_policy_context_variable_changed(u, args.variable, args.value);
-
- } while (dbus_message_iter_next(actit));
-
- return TRUE;
-}
-
-static void registration_cb(DBusPendingCall *pend, void *data)
+static void murphy_registration_cb(DBusPendingCall *pend, void *data)
{
struct userdata *u = (struct userdata *)data;
DBusMessage *reply;
int success;
if ((reply = dbus_pending_call_steal_reply(pend)) == NULL || u == NULL) {
- pa_log("%s: registartion setting failed: invalid argument", __FILE__);
+ pa_log("%s: Murphy registartion setting failed: "
+ "invalid argument", __FILE__);
return;
}
if (!success)
error_descr = dbus_message_get_error_name(reply);
- pa_log_info("%s: registration to policy decision point failed: %s",
+ pa_log_info("%s: registration to Murphy failed: %s",
__FILE__, error_descr);
}
else {
pa_log_info("got reply to registration");
if (u->dbusif) {
- u->dbusif->regist = 1;
+ u->dbusif->amisup = 1;
}
}
dbus_message_unref(reply);
}
-static int register_to_pdp(struct pa_policy_dbusif *dbusif, struct userdata *u)
+static int register_to_murphy(struct pa_policy_dbusif *dbusif,
+ struct userdata *u)
{
static const char *name = "pulseaudio";
int i;
int success;
- pa_log_info("%s: registering to policy daemon: name='%s' path='%s' if='%s'"
- , __FILE__, dbusif->pdnam, dbusif->pdpath, dbusif->ifnam);
+ pa_log_info("%s: registering to murphy: name='%s' path='%s' if='%s'"
+ , __FILE__, dbusif->mrpnam, dbusif->mrppath, dbusif->ifnam);
- msg = dbus_message_new_method_call(dbusif->pdnam, dbusif->pdpath,
+ msg = dbus_message_new_method_call(dbusif->mrpnam, dbusif->mrppath,
dbusif->ifnam, "register");
if (msg == NULL) {
goto failed;
}
- success = dbus_pending_call_set_notify(pend, registration_cb, u, NULL);
+ success = dbus_pending_call_set_notify(pend,murphy_registration_cb,u,NULL);
if (!success) {
pa_log("%s: Can't set notification for registartion", __FILE__);
return 0;
}
- snprintf(path, sizeof(path), "%s/%s", dbusif->pdpath, POLICY_DECISION);
+ snprintf(path, sizeof(path), "%s/%s", dbusif->mrppath, POLICY_DECISION);
pa_log_debug("sending signal to: path='%s', if='%s' member='%s' "
"content: txid=%d status=%d", path, dbusif->ifnam,
return -1;
}
+/**************************************************************************
+ *
+ * Audio Manager interfaces
+ *
+ */
+static void audiomgr_registration_cb(DBusPendingCall *pend, void *data)
+{
+ struct userdata *u = (struct userdata *)data;
+ DBusMessage *reply;
+ const char *error_descr;
+ int success;
+
+ if ((reply = dbus_pending_call_steal_reply(pend)) == NULL || u == NULL) {
+ pa_log("%s: AudioManager registartion setting failed: "
+ "invalid argument", __FILE__);
+ return;
+ }
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ success = dbus_message_get_args(reply, NULL,
+ DBUS_TYPE_STRING, &error_descr,
+ DBUS_TYPE_INVALID);
+
+ if (!success)
+ error_descr = dbus_message_get_error_name(reply);
+
+ pa_log_info("%s: registration to AudioManager failed: %s",
+ __FILE__, error_descr);
+ }
+ else {
+ pa_log_info("got reply to registration");
+
+ if (u->dbusif) {
+ u->dbusif->amisup = 1;
+ }
+ }
+
+ dbus_message_unref(reply);
+}
+
+static int register_to_audiomgr(struct pa_policy_dbusif *dbusif,
+ struct userdata *u)
+{
+ DBusConnection *conn = pa_dbus_connection_get(dbusif->conn);
+ DBusMessage *msg;
+ DBusPendingCall *pend;
+ uint16_t domain_id;
+ const char *name;
+ const char *bus_name;
+ const char *node_name;
+ dbus_bool_t early;
+ dbus_bool_t complete;
+ uint16_t state;
+ int success;
+
+ pa_log_info("%s: registering to AudioManager: name='%s' path='%s' if='%s'"
+ , __FILE__, dbusif->amnam, dbusif->amrpath, dbusif->amrnam);
+
+ msg = dbus_message_new_method_call(dbusif->amnam,
+ dbusif->amrpath,
+ dbusif->amrnam,
+ AUDIOMGR_REGISTER_DOMAIN);
+ if (msg == NULL) {
+ pa_log("%s: Failed to create D-Bus message to register", __FILE__);
+ success = FALSE;
+ goto failed;
+ }
+
+ domain_id = 0;
+ name = AUDIOMGR_DOMAIN;
+ bus_name = AUDIOMGR_NODE;
+ node_name = AUDIOMGR_NODE;
+ early = FALSE;
+ complete = FALSE;
+ state = 0;
+
+ success = dbus_message_append_args(msg,
+ DBUS_TYPE_UINT16, &domain_id,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_STRING, &node_name,
+ DBUS_TYPE_STRING, &bus_name,
+ DBUS_TYPE_BOOLEAN, &early,
+ DBUS_TYPE_BOOLEAN, &complete,
+ DBUS_TYPE_UINT16 , &state,
+ DBUS_TYPE_STRING , &name, /* ??? */
+ DBUS_TYPE_STRING , &node_name, /* ??? */
+ DBUS_TYPE_STRING , &node_name, /* ??? */
+ DBUS_TYPE_INVALID);
+ if (!success) {
+ pa_log("%s: Failed to build D-Bus message to register", __FILE__);
+ goto failed;
+ }
+
+
+ success = dbus_connection_send_with_reply(conn, msg, &pend, 10000);
+ if (!success) {
+ pa_log("%s: Failed to register", __FILE__);
+ goto failed;
+ }
+
+ success = dbus_pending_call_set_notify(pend, audiomgr_registration_cb,
+ u, NULL);
+
+ if (!success) {
+ pa_log("%s: Can't set notification for registartion", __FILE__);
+ }
+
+ failed:
+ dbus_message_unref(msg);
+ return success;
+}
+
/*
* Local Variables:
projects / profile / ivi / pulseaudio-module-murphy-ivi.git / commitdiff