static DBusMessage*
service_message_handler (GkdSecretService *self, DBusMessage *message)
{
g_return_val_if_fail (message, NULL);
g_return_val_if_fail (GKD_SECRET_IS_SERVICE (self), NULL);
/* org.freedesktop.Secret.Service.OpenSession() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "OpenSession"))
return service_method_open_session (self, message);
/* org.freedesktop.Secret.Service.CreateCollection() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "CreateCollection"))
return service_method_create_collection (self, message);
/* org.freedesktop.Secret.Service.LockService() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "LockService"))
return service_method_lock_service (self, message);
/* org.freedesktop.Secret.Service.SearchItems() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "SearchItems"))
return gkd_secret_objects_handle_search_items (self->objects, message, NULL);
/* org.freedesktop.Secret.Service.GetSecrets() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "GetSecrets"))
return gkd_secret_objects_handle_get_secrets (self->objects, message);
/* org.freedesktop.Secret.Service.Unlock() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "Unlock"))
return service_method_unlock (self, message);
/* org.freedesktop.Secret.Service.Lock() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "Lock"))
return service_method_lock (self, message);
/* org.mate.keyring.Service.ChangeLock() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "ChangeLock"))
return service_method_change_lock (self, message);
/* org.freedesktop.Secret.Service.ReadAlias() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "ReadAlias"))
return service_method_read_alias (self, message);
/* org.freedesktop.Secret.Service.SetAlias() */
if (dbus_message_is_method_call (message, SECRET_SERVICE_INTERFACE, "SetAlias"))
return service_method_set_alias (self, message);
/* org.mate.keyring.InternalUnsupportedGuiltRiddenInterface.CreateWithMasterPassword */
if (dbus_message_is_method_call (message, INTERNAL_SERVICE_INTERFACE, "CreateWithMasterPassword"))
return service_method_create_with_master_password (self, message);
/* org.mate.keyring.InternalUnsupportedGuiltRiddenInterface.ChangeWithMasterPassword() */
if (dbus_message_is_method_call (message, INTERNAL_SERVICE_INTERFACE, "ChangeWithMasterPassword"))
return service_method_change_with_master_password (self, message);
/* org.mate.keyring.InternalUnsupportedGuiltRiddenInterface.UnlockWithMasterPassword() */
if (dbus_message_is_method_call (message, INTERNAL_SERVICE_INTERFACE, "UnlockWithMasterPassword"))
return service_method_unlock_with_master_password (self, message);
/* org.freedesktop.DBus.Properties.Get() */
if (dbus_message_is_method_call (message, DBUS_INTERFACE_PROPERTIES, "Get"))
return service_property_get (self, message);
/* org.freedesktop.DBus.Properties.Set() */
else if (dbus_message_is_method_call (message, DBUS_INTERFACE_PROPERTIES, "Set"))
return service_property_set (self, message);
/* org.freedesktop.DBus.Properties.GetAll() */
else if (dbus_message_is_method_call (message, DBUS_INTERFACE_PROPERTIES, "GetAll"))
return service_property_getall (self, message);
else if (dbus_message_has_interface (message, DBUS_INTERFACE_INTROSPECTABLE))
return gkd_dbus_introspect_handle (message, gkd_secret_introspect_service);
return NULL;
}
DBusHandlerResult timer_adaptor::handle_message(DBusConnection* connection, DBusMessage* message)
{
std::clog << __FUNCTION__ << std::endl;
assert(dbus_message_has_interface(message, INTERFACE_NAME));
auto dst = dbus_message_get_path(message);
if (dst == nullptr || strlen(dst) == 0) {
std::cerr << "Unknown message destination" << std::endl;
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
auto obj = m_objects.find(dst);
if (obj == m_objects.end()) {
std::cerr << "Destination object " << dst << " not found" << std::endl;
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
auto name = dbus_message_get_member(message);
if (name == nullptr || strlen(name) == 0) {
std::cerr << "Unknown method name " << std::endl;
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
typedef dboost::dbus_ptr<DBusMessage> (timer_adaptor::*caller)(timer*, DBusMessage*);
typedef std::map<std::string, caller> caller_table;
static const caller_table vtbl {
{"add_timer", &timer_adaptor::call_add_timer},
{"remove_timer", &timer_adaptor::call_remove_timer}
};
auto func = vtbl.find(name);
if (func == vtbl.end()) {
std::cerr << "Wrong method name " << name << std::endl;
return DBUS_HANDLER_RESULT_HANDLED;
}
auto result = (this->*func->second)(obj->second, message);
std::clog << "Reply result" << std::endl;
dbus_connection_send(connection, result.get(), 0);
return DBUS_HANDLER_RESULT_HANDLED;
}
/**
* mafw_proxy_renderer_dispatch_message:
* @conn: pointer to a private DBus connection
* @msg: the DBus message
* @data: User data
*
* Handles the received DBus messages
* Returns: Whether the message was handled or not
*/
static DBusHandlerResult
mafw_proxy_renderer_dispatch_message(DBusConnection *conn,
DBusMessage *msg,
gpointer data)
{
MafwProxyRenderer *self;
g_assert(conn != NULL);
g_assert(msg != NULL);
self = MAFW_PROXY_RENDERER(data);
if (dbus_message_has_interface(msg, MAFW_EXTENSION_INTERFACE))
return proxy_extension_dispatch(conn, msg, self);
/* Dispatch message. */
if (mafw_dbus_is_signal(msg, MAFW_RENDERER_SIGNAL_STATE_CHANGED)) {
mafw_proxy_renderer_handle_signal_state_changed(self, msg);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (mafw_dbus_is_signal(msg,
MAFW_RENDERER_SIGNAL_PLAYLIST_CHANGED)) {
mafw_proxy_renderer_handle_signal_playlist_changed(self, msg);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (mafw_dbus_is_signal(msg,
MAFW_RENDERER_SIGNAL_ITEM_CHANGED)) {
mafw_proxy_renderer_handle_signal_media_changed(self, msg);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (mafw_dbus_is_signal(msg,
MAFW_RENDERER_SIGNAL_BUFFERING_INFO)) {
mafw_proxy_renderer_handle_signal_buffering_info(self, msg);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (mafw_dbus_is_signal(msg,
MAFW_RENDERER_SIGNAL_METADATA_CHANGED)) {
mafw_proxy_renderer_handle_signal_metadata_changed(self, msg);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
bool SignalMessage::has_interface( const std::string& i ) const
{
return dbus_message_has_interface( m_cobj, i.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;
}
