DBusHandlerResult dbus_status_item_filter(DBusConnection *connection,DBusMessage * msg,void */* data*/){
// DEBUG_DBUS_MESSAGE(msg);
DBusMessage * reply;
DBusMessageIter iter;
DBusMessageIter dict;
//DBusMessageIter dictentry;
FXuint serial;
if (dbus_message_has_path(msg,APPLICATION_STATUS_ITEM_PATH)){
DEBUG_DBUS_MESSAGE(msg);
if (dbus_message_has_interface(msg,APPLICATION_STATUS_ITEM_INTERFACE)) {
if (dbus_message_is_method_call(msg,APPLICATION_STATUS_ITEM_INTERFACE,"Activate")){
GMPlayerManager::instance()->cmd_toggle_shown();
return gm_dbus_reply_if_needed(connection,msg);
}
else if (dbus_message_is_method_call(msg,APPLICATION_STATUS_ITEM_INTERFACE,"Scroll")){
FXint delta;
const FXchar * orientation;
if (dbus_message_get_args(msg,NULL,DBUS_TYPE_INT32,&delta,DBUS_TYPE_STRING,&orientation,DBUS_TYPE_INVALID)) {
//FIXME
FXint level = GMPlayerManager::instance()->volume();
level+=(delta/120);
GMPlayerManager::instance()->volume(level);
}
return gm_dbus_reply_if_needed(connection,msg);
}
}
else if (dbus_message_has_interface(msg,DBUS_INTERFACE_INTROSPECTABLE)) {
if (dbus_message_is_method_call(msg,DBUS_INTERFACE_INTROSPECTABLE,"Introspect")){
return gm_dbus_reply_string(connection,msg,appstatus_xml);
}
}
else if (dbus_message_has_interface(msg,DBUS_INTERFACE_PROPERTIES)) {
if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"Get")){
GM_DEBUG_PRINT("get\n");
}
else if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"GetAll")){
if ((reply=dbus_message_new_method_return(msg))!=NULL) {
dbus_message_iter_init_append(reply,&iter);
dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,"{sv}",&dict);
gm_dbus_dict_append_path(&dict,"Menu",APPLICATION_STATUS_ITEM_MENU_PATH);
gm_dbus_dict_append_string(&dict,"Category","ApplicationStatus");
gm_dbus_dict_append_string(&dict,"Id","gogglesmm");
gm_dbus_dict_append_string(&dict,"IconName","gogglesmm");
gm_dbus_dict_append_string(&dict,"Status","Active");
gm_dbus_dict_append_uint32(&dict,"WindowId",GMPlayerManager::instance()->getMainWindowId());
gm_add_tooltip(&dict);
dbus_message_iter_close_container(&iter,&dict);
dbus_connection_send(connection,reply,&serial);
dbus_message_unref(reply);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
else if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"Set")){
}
}
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
on_prompt_signal (DBusConnection *connection, DBusMessage *message, void *user_data)
{
on_prompt_args *args = user_data;
DBusMessageIter iter;
dbus_bool_t dismissed;
GkrOperation *op;
const char *object_name;
const char *new_owner;
const char *old_owner;
g_assert (args);
if (!args->path || !args->op->prompting)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
/* org.freedesktop.Secret.Prompt.Completed(BOOLEAN dismissed, VARIANT result) */
if (dbus_message_has_path (message, args->path) &&
dbus_message_is_signal (message, PROMPT_INTERFACE, "Completed")) {
/* Only one call, even if daemon decides to be strange */
g_free (args->path);
args->path = NULL;
if (!dbus_message_iter_init (message, &iter) ||
dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_BOOLEAN)
g_return_val_if_reached (BROKEN);
dbus_message_iter_get_basic (&iter, &dismissed);
op = gkr_operation_ref (args->op);
if (dismissed)
gkr_operation_complete (op, MATE_KEYRING_RESULT_CANCELLED);
else
callback_with_message (op, message);
if (op->prompting)
dbus_connection_remove_filter (args->op->conn, on_prompt_signal, args);
gkr_operation_unref (op);
return DBUS_HANDLER_RESULT_HANDLED;
}
/* org.freedesktop.DBus.NameOwnerChanged(STRING name, STRING old_owner, STRING new_owner) */
if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS, "NameOwnerChanged") &&
dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &object_name,
DBUS_TYPE_STRING, &old_owner, DBUS_TYPE_STRING, &new_owner,
DBUS_TYPE_INVALID)) {
/* See if it's the secret service going away */
if (object_name && g_str_equal (gkr_service_name (), object_name) &&
new_owner && g_str_equal ("", new_owner)) {
g_message ("Secret service disappeared while waiting for prompt");
op = gkr_operation_ref (args->op);
gkr_operation_complete (op, MATE_KEYRING_RESULT_IO_ERROR);
if (op->prompting)
dbus_connection_remove_filter (args->op->conn, on_prompt_signal, args);
gkr_operation_unref (op);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
bool SignalMessage::has_path( const std::string& p ) const
{
return dbus_message_has_path( m_cobj, p.c_str() );
}
static DBusHandlerResult
mafw_proxy_source_dispatch_message(DBusConnection *conn,
DBusMessage *msg,
MafwProxySource *self)
{
MafwProxySourcePrivate *priv;
gchar *domain_str;
gint code;
gchar *message;
GError *error = NULL;
g_assert(conn != NULL);
g_assert(msg != NULL);
priv = MAFW_PROXY_SOURCE_GET_PRIVATE(self);
if (dbus_message_has_interface(msg, MAFW_EXTENSION_INTERFACE))
return proxy_extension_dispatch(conn, msg, self);
if (dbus_message_has_member(msg,
MAFW_PROXY_SOURCE_METHOD_BROWSE_RESULT)) {
MafwProxySourceBrowseReq *new_req = NULL;
guint browse_id;
gint remaining_count;
guint index;
gchar *object_id;
GHashTable *metadata;
DBusMessageIter imsg, iary, istr;
g_return_val_if_fail(
priv->browse_requests != NULL,
DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
dbus_message_iter_init(msg, &imsg);
dbus_message_iter_get_basic(&imsg, &browse_id);
dbus_message_iter_next(&imsg);
g_assert(dbus_message_iter_get_arg_type(&imsg) ==
DBUS_TYPE_ARRAY);
dbus_message_iter_recurse(&imsg, &iary);
while (dbus_message_iter_get_arg_type(&iary) !=
DBUS_TYPE_INVALID)
{
dbus_message_iter_recurse(&iary, &istr);
g_assert(dbus_message_iter_get_arg_type(&istr)
== DBUS_TYPE_INT32);
dbus_message_iter_get_basic(&istr,
&remaining_count);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &index);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &object_id);
dbus_message_iter_next(&istr);
mafw_dbus_message_parse_metadata(&istr,
&metadata);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &domain_str);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &code);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &message);
if (domain_str && domain_str[0])
g_set_error(&error,
g_quark_from_string(domain_str),
code, "%s", message);
dbus_message_iter_next(&iary);
if (!new_req)
{
new_req = g_hash_table_lookup(
priv->browse_requests,
GUINT_TO_POINTER(browse_id));
if (new_req)
new_req->emitting = TRUE;
}
if (new_req) {
new_req->browse_cb(MAFW_SOURCE(self),
browse_id,
remaining_count,
index,
object_id[0] ?
object_id :
NULL,
metadata,
new_req->user_data,
error);
if (remaining_count == 0 || new_req->stop_emitting)
{
g_hash_table_remove(
priv->browse_requests,
GUINT_TO_POINTER(browse_id));
new_req = NULL;
g_clear_error(&error);
mafw_metadata_release(metadata);
break;
}
}
else
{
g_clear_error(&error);
mafw_metadata_release(metadata);
break;
}
g_clear_error(&error);
mafw_metadata_release(metadata);
}
if (new_req) {
new_req->emitting = FALSE;
}
return DBUS_HANDLER_RESULT_HANDLED;
} else if (!dbus_message_has_path(msg,
proxy_extension_return_path(self))) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_METADATA_CHANGED)) {
return handle_metadata_changed_signal(self, msg);
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_CONTAINER_CHANGED)) {
return handle_container_changed_signal(self, msg);
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_UPDATING)) {
return handle_updating_signal(self, msg);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
filter_cb (DBusConnection *connection, DBusMessage *msg, void *data)
{
(void) connection;
(void) data;
const char *obj_path;
char *stream_name;
GList *list, *i;
SubscribeItem *item;
int volume = 0;
if (dbus_message_has_interface (msg, DBUS_INTERFACE_LOCAL) &&
dbus_message_has_path (msg, DBUS_PATH_LOCAL) &&
dbus_message_has_member (msg, DISCONNECTED_SIG))
{
N_DEBUG (LOG_CAT "pulseaudio disconnected, reconnecting in %d seconds",
RETRY_TIMEOUT);
disconnect_from_pulseaudio ();
// After disconnecting re-query stream restore object names.
if (subscribe_map && object_map) {
list = g_hash_table_get_values (subscribe_map);
for (i = g_list_first (list); i; i = g_list_next (i)) {
SubscribeItem *item = (SubscribeItem*) i->data;
if (item->object_path) {
g_free (item->object_path);
item->object_path = NULL;
}
}
g_list_free (list);
queue_subscribe = TRUE;
}
// If PulseAudio is restarting path to runtime files may change so we'll
// have to request DBus address again.
if (volume_pulse_address) {
g_free(volume_pulse_address);
volume_pulse_address = NULL;
}
retry_connect();
}
else if (subscribe_callback &&
dbus_message_has_interface (msg, STREAM_RESTORE_IF) &&
dbus_message_has_path (msg, STREAM_RESTORE_PATH) &&
dbus_message_has_member (msg, NEW_ENTRY_MEMBER))
{
if (!dbus_message_get_args (msg, NULL, DBUS_TYPE_OBJECT_PATH, &obj_path, DBUS_TYPE_INVALID)) {
N_WARNING (LOG_CAT "failed to get arguments for new entry");
goto end;
}
// If the entry is in subscribe_map but not in object_map, look up the entry
// and add to object_map
if (!object_map_complete && !g_hash_table_lookup (object_map, obj_path)) {
if ((stream_name = get_object_name (obj_path))) {
if ((item = g_hash_table_lookup (subscribe_map, stream_name))) {
item->object_path = g_strdup (obj_path);
N_DEBUG (LOG_CAT "stream restore entry for %s appeared (%s)", item->stream_name, item->object_path);
update_object_map_listen ();
}
g_free (stream_name);
}
}
}
else if (subscribe_callback &&
dbus_message_has_interface (msg, STREAM_RESTORE_IF) &&
dbus_message_has_path (msg, STREAM_RESTORE_PATH) &&
dbus_message_has_member (msg, ENTRY_REMOVED_MEMBER))
{
if (!dbus_message_get_args (msg, NULL, DBUS_TYPE_OBJECT_PATH, &obj_path, DBUS_TYPE_INVALID)) {
N_WARNING (LOG_CAT "failed to get arguments for removed entry");
goto end;
}
if ((item = g_hash_table_lookup (object_map, obj_path))) {
g_hash_table_remove (object_map, item->object_path);
g_free (item->object_path);
item->object_path = NULL;
update_object_map_listen ();
N_DEBUG (LOG_CAT "removed entry %s from object map (%s)", item->stream_name, obj_path);
}
}
else if (subscribe_callback &&
dbus_message_has_interface (msg, STREAM_ENTRY_IF) &&
dbus_message_has_member (msg, VOLUME_UPDATED_MEMBER))
{
if (!(obj_path = dbus_message_get_path (msg)))
goto end;
if ((item = g_hash_table_lookup (object_map, obj_path))) {
N_DEBUG (LOG_CAT "volume updated for stream %s (%s)", item->stream_name, item->object_path);
if (get_volume (msg, &volume)) {
subscribe_callback (item->stream_name, FROM_PA_VOL(volume), item->data, subscribe_userdata);
}
}
}
end:
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult dbus_dbusmenu_filter(DBusConnection *connection,DBusMessage * msg,void * /*data*/){
//GMAppStatusNotify * p = reinterpret_cast<GMAppStatusNotify*>(data);
DEBUG_DBUS_MESSAGE(msg);
DBusMessage * reply;
DBusMessageIter iter;
DBusMessageIter item;
DBusMessageIter list;
FXuint serial;
if (dbus_message_has_path(msg,APPLICATION_STATUS_ITEM_MENU_PATH)){
if (dbus_message_has_interface(msg,DBUS_INTERFACE_INTROSPECTABLE)) {
if (dbus_message_is_method_call(msg,DBUS_INTERFACE_INTROSPECTABLE,"Introspect")){
return gm_dbus_reply_string(connection,msg,dbusmenu_xml);
}
}
else if (dbus_message_has_interface(msg,DBUS_INTERFACE_PROPERTIES)) {
if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"Get")){
}
else if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"GetAll")){
}
else if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"Set")){
}
}
else if (dbus_message_has_interface(msg,DBUS_MENU_INTERFACE)) {
if (dbus_message_is_method_call(msg,DBUS_MENU_INTERFACE,"GetLayout")){
FXint parent,depth;
FXchar ** properties=NULL;
FXint nprops;
if (dbus_message_get_args(msg,NULL,DBUS_TYPE_INT32,&parent,DBUS_TYPE_INT32,&depth,DBUS_TYPE_ARRAY,DBUS_TYPE_STRING,&properties,&nprops,DBUS_TYPE_INVALID)) {
if ((reply=dbus_message_new_method_return(msg))!=NULL) {
FXuint revision=1;
dbus_message_iter_init_append(reply,&iter);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_UINT32,&revision);
gm_begin_menu(&iter,&item,ID_ROOT,"Goggles Music Manager","gogglesmm");
gm_begin_menu_item_list(&item,&list);
if (depth==-1 || depth==1) {
gm_make_menu_item(&list,ID_PLAY,"Play","media-playback-start",GMPlayerManager::instance()->can_play());
gm_make_menu_item(&list,ID_PAUSE,"Pause","media-playback-pause",GMPlayerManager::instance()->can_pause());
gm_make_menu_item(&list,ID_STOP,"Stop","media-playback-stop",GMPlayerManager::instance()->can_stop());
gm_make_menu_item(&list,ID_PREVIOUS,"Previous Track","media-skip-backward",GMPlayerManager::instance()->can_prev());
gm_make_menu_item(&list,ID_NEXT,"Next Track","media-skip-forward",GMPlayerManager::instance()->can_next());
}
gm_end_menu_item_list(&item,&list);
gm_end_menu(&iter,&item);
dbus_connection_send(connection,reply,&serial);
dbus_message_unref(reply);
}
dbus_free_string_array(properties);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
else if (dbus_message_is_method_call(msg,DBUS_MENU_INTERFACE,"AboutToShow")) {
FXint event_id;
if (dbus_message_get_args(msg,NULL,DBUS_TYPE_INT32,&event_id,DBUS_TYPE_INVALID)) {
gm_dbus_reply_bool(connection,msg,false);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
else if (dbus_message_is_method_call(msg,DBUS_MENU_INTERFACE,"Event")) {
FXint event_id;
const FXchar * event_type=NULL;
if (dbus_message_get_args(msg,NULL,DBUS_TYPE_INT32,&event_id,DBUS_TYPE_STRING,&event_type,DBUS_TYPE_INVALID)) {
if (compare(event_type,"clicked")==0) {
switch(event_id) {
case ID_PLAY : GMPlayerManager::instance()->cmd_play(); break;
case ID_PAUSE : GMPlayerManager::instance()->cmd_pause(); break;
case ID_STOP : GMPlayerManager::instance()->cmd_stop(); break;
case ID_NEXT : GMPlayerManager::instance()->cmd_next(); break;
case ID_PREVIOUS: GMPlayerManager::instance()->cmd_prev(); break;
}
}
return DBUS_HANDLER_RESULT_HANDLED;
}
}
}
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
